# -*- coding: utf-8 -*-
import random
import packaging
from adbutils import adb
from weixin_modules.oper_database import *
from weixin_modules.wechat import *
from weixin_modules.other_fun import get_puyang_keys, deal_name_text, is_in_list, is_rooms, is_company_room, \
    dec_to_base32, is_homepage
import settings

logger = logging.getLogger("uiauto_weixin.weixin_modules.weixin")


class WeixinTest:

    def __init__(self, serialno_url):
        # 判断 微信的版本号，8.0.40以后，app的层发生了变化 ，
        ver = packaging.version.parse("8.0.41")
        d = adb.device(serialno_url)
        info = d.app_info("com.tencent.mm")
        logger.info(f"微信版本号：{info.version_name}, version_code:{info.version_code}")
        if packaging.version.parse(info.version_name) < ver:
            self.wechat = wechat(serialno_url)
            logger.info("选择微信运行 第1版")
        else:
            logger.info("选择微信运行 第2版")
            self.wechat = wechat_2(serialno_url)

        self.serialno = self.wechat.serial
        #########################################################
        # 预制参数
        self.other_list = ["微信运动", "文件传输助手", "微信支付", "折叠的群聊", "订阅号消息", "服务通知",
                           "微信支付商家助手", "腾讯新闻", "已注销的微信用户", "微信团队"]
        self.nick_name = None
        self.wxid = None
        self.tag_id = None
        # 点击返回后的等待时间,
        self.back_wait_time = 0.5
        # 濮阳关键字，
        self.puyang_keys = get_puyang_keys()
        # # 品牌
        # self.device_manufacturer = self.wechat.device_manufacturer
        # # 型号,
        # self.device_model = self.wechat.device_model
        # 1FABA 🪺 NEST WITH EGGS 蛋窝 标志，用于标识微信群，
        self.flag_rooms = chr(0x1FABA)
        self.flag_rooms2 = chr(0x1FAB9)
        # 1FAAA 🪪 IDENTIFICATION CARD
        # 用于识别好友，
        self.flag_friend = chr(0x1FAAA)
        self.room_serialno = None
        # 群发任务
        self.task_id = None
        self.task_message = None
        self.task_rooms = None
        #
        self.friend_serialno = None
        #########################################################

        # # 唤醒手机,
        self.wechat.wake()
        # 进入微信,
        self.enter_wx()
        self.get_current_wxinfo()
        #####################################
        # 初始化数据库，
        self.database = OperDatabase(self.wxid)
        self.tag_id = self.database.select_user(self.nick_name, self.wxid)
        self.wechat.info_area = self.wechat.get_info_area()
        #####################################
        # 控制参数
        self.internal_flag_auto_accept_friend_invitations = 1
        # 临时用法，设置默认等待时间，
        self.weinxinTest_default_waiting_time = 2
        if self.wechat.serial == "721QADRP232N4":
            self.weinxinTest_default_waiting_time = 6

    def clicks(self, uis: list):
        """
        同一个目标,多次尝试点击不同的元素,
        :param uis:
        :return:
        """
        for ui in uis:
            try:
                ui.click(timeout=4)
                return True
            except Exception as e:
                logger.error("Caught an exception:", e)
                logger.error(ui)
                self.wechat.debug_save(self.serialno)
        # TODO:下载当前xml文件,截图保存,
        # 抛出异常并附加额外信息
        raise Exception("发生错误")

    def screen_off(self):
        self.wechat.screen_turn_off()

    def is_puyang(self, name_text):
        """
        判断名字中是否包含 关于濮阳的关键字，
        :param name_text:
        :return:
        """
        for key in self.puyang_keys:
            if key in name_text:
                return True
        return False

    def enter_wx(self):
        """
        进入微信
        :return:
        """
        self.wechat.switch_to_wechat()
        # TODO: 这里还需要加其它判断，
        # if not self.wechat.navbar.wait(timeout=5):
        #     logger.debug("微信导航栏不存在")
        #     self.wechat.keyback_homepage()
        logger.info(f'进入微信：{self.wechat.prop}')

    def get_current_wxinfo(self):
        """
        获取连接的手机上的微信 信息，
        :return:
        """
        # :进入 我，识别名字和wxid,
        # 解决 IQOO z7i 手机，点击 <我>， 失败的问题，
        # uiautomator2.exceptions.UiObjectNotFoundError: -32002 Client error: <> data:
        # Selector [resourceId='com.tencent.mm:id/h7q', text='我'], method: None

        # try:
        #     self.wechat.navbar_me.click(timeout=5)
        # except Exception as e:
        #     logger.debug("点击<我>发异常：{}\n==>下载hir".format(e))
        #     self.wechat.debug_save(self.serialno)
        #     self.wechat.navbar_me_2.click()
        self.clicks(self.wechat.pro_navbar_me)

        nick_name = self.wechat.me_nick_name.get_text()
        # 总结 应该是两个限制 ，UTF-8最长为36，字符对象最多为23，
        self.nick_name = nick_name.strip()
        if self.nick_name.endswith("…"):
            self.nick_name = self.nick_name[:-1]
        # 微信号：wxid_6n4jvt7px62p22
        wxid = self.wechat.me_wxid.get_text()
        wxid = wxid[4:]
        self.wxid = wxid.strip()
        logger.info(f"当前微信名：{self.nick_name}")
        logger.info(f"当前微信号：{wxid}")

    def room_fold(self):
        """
        微信群的 聊天信息界面，点击 折叠到群聊
        :return:
        """
        # 点击 <消息免打扰>,最多点击 10次，少用while True
        for i in range(5):
            if self.wechat.room_switchs.exists():
                break
            self.wechat.swipe_up(0.6, 0.4)
        for i in range(10):
            self.wechat.room_switchs[0].click()
            time.sleep(0.4)
            if self.wechat.is_closed(self.wechat.room_switchs[0]):
                logger.debug("还是关闭状态，再点击一下")
            else:
                break
        else:
            raise Exception("点击10次了，还是关闭状态，需要检查，")
        # 点击 <折叠该群聊>
        for i in range(10):
            self.wechat.room_switchs[1].click()
            # 点击 折叠群聊 后，可能出现弹窗，
            self.wechat.room_popup_tohide.click_exists(timeout=1)
            time.sleep(0.4)
            if self.wechat.is_closed(self.wechat.room_switchs[1]):
                logger.debug("还是关闭状态，再点击一下")
            else:
                break
        else:
            raise Exception("点击10次了，还是关闭状态，需要检查，")

    def room_unfold(self):
        """
        微信群，取消折叠，
        :return:
        """
        logger.debug("取消折叠")
        # 点击 折叠该群聊，
        # 判断 折叠该群聊，是不是关闭状态，
        # 点击 免打扰
        deadline = time.time() + WeixinTest_button_timeout
        while not self.wechat.room_label_toFold.wait(timeout=2):
            # <折叠该群聊> 不存在 ，就再点击一下 <消息免打扰>
            self.wechat.room_switchs[0].click()
            if time.time() > deadline:
                logger.debug("点击按钮超时，强制结束，")
                break
        deadline = time.time() + WeixinTest_button_timeout
        while True:
            self.wechat.room_switchs[1].click()

            time.sleep(self.weinxinTest_default_waiting_time)
            if self.wechat.is_closed(self.wechat.room_switchs[1]):
                break
            else:
                logger.debug("还是打开状态，再点击一下")
            if time.time() > deadline:
                logger.debug("点击按钮超时，强制结束，")
                break

    def room_switch_save_tobook(self):
        """
        微信群的 聊天信息界面，点击 保存到通讯录

        :return:
        """
        logger.debug("点击 保存到通讯录")
        deadline = time.time() + WeixinTest_button_timeout
        while not self.wechat.room_label_saveToBook.wait(timeout=0.5):
            self.wechat.swipe_up(0.6, 0.4)
            if time.time() > deadline:
                logger.debug("没有找到，强制结束，")
                raise Exception("没有找到，强制结束，")
        deadline = time.time() + WeixinTest_button_timeout
        while self.wechat.is_closed(self.wechat.room_switch_save_tobook):
            logger.debug("关闭状态，点击一下")
            self.flag_auto_get_rooms_area = 1
            self.wechat.room_switch_save_tobook.click()
            time.sleep(0.4)
            if time.time() > deadline:
                logger.debug("点击按钮超时，强制结束，")
                break

    def get_one_friend(self):
        """
        在微信好友 详情界面获取信息，
        :param poco:
        :return:
        """
        # 获取昵称，有可能不存在，需要先判断，
        # 昵称 nick_name
        # 备注名称： wx_alias
        logger.debug("进入 get_one_friend")
        self.wechat.friend_first_name.wait(timeout=3)
        if self.wechat.friend_second_name.wait(timeout=0.5):
            logger.debug("有备注名称")
            nick_name = self.wechat.friend_second_name.get_text()
            # 昵称:  AA职工社保客服
            nick_name = nick_name[3:]
            nick_name = nick_name.strip()
            nick_name = deal_name_text(nick_name)
            wx_alias = self.wechat.friend_first_name.get_text()
            wx_alias = wx_alias.strip()
            wx_alias = deal_name_text(wx_alias)
        else:
            # 获取 当前名字全称，有可能是备注的名字，  A0银行贷款雷学会18839391140
            logger.debug("没有备注名称")
            wx_alias = "空"
            if self.wechat.friend_first_name.wait(timeout=5):
                nick_name = self.wechat.friend_first_name.get_text()
                nick_name = nick_name.strip()
                nick_name = deal_name_text(nick_name)
            else:
                logger.debug("没有任何名字")
                nick_name = "空"
        # 获取微信号  例： 微信号:  wxid_xe7splotqru922
        if self.wechat.friend_wxid.wait(timeout=0.5):
            wxid = self.wechat.friend_wxid.get_text()
            wxid = wxid[4:]
            wxid = wxid.strip()
        else:
            wxid = "空"
        # 获取 地区信息，有可能不存在，需要判断，，例：地区:  河南  濮阳
        if self.wechat.friend_area.wait(timeout=0.5):
            area = self.wechat.friend_area.get_text()
            area = area[3:]
            area = area.strip()
        else:
            area = "空"
        values = friend_info_dict.copy()
        values["nick_name"] = nick_name
        values["wx_alias"] = wx_alias
        values["wxid"] = wxid
        values["area"] = area
        values["tag_id"] = self.tag_id
        values["update_time"] = int(time.time())

        # logger.debug(f"get_one_friend 获取的 信息：{values}")
        return values

    def get_public_accounts(self):
        """
        获取公众号信息，获取后直接写入，

        :return:
        """
        # 进入 通讯录，
        self.wechat.navbar_book.click()
        # 第二次点击，复位到通讯录顶部
        self.wechat.navbar_book.click()
        # 获取微信公众号名称，这个应该是唯一，不重复的
        # self.wechat.book_public_account.click()
        self.wechat.book_public_account.click_gone()

        # 新手机号，可能没有关注公众号，
        if self.wechat.public_account_bottom_tip.wait(timeout=3):
            label_text = self.wechat.public_account_bottom_tip.get_text()
            label_text.strip()
            logger.info(label_text)
            if label_text.startswith("0"):
                if not self.wechat.public_account_items.wait(timeout=3):
                    # 两重判断，出现 “0个公众号”
                    # 并且没有 结点 "com.tencent.mm:id/aip"
                    # self.wechat.key_back()
                    # self.wechat.book_public_account.wait(timeout=3.0)
                    self.wechat.keyback_wait_for_appearance(self.wechat.book_public_account)
                    return
        not_end = 0
        temp_list = []
        while not_end < 30:
            info_list = []
            aip_list = self.wechat.public_account_items
            for aip in aip_list:
                account = aip.get_text()
                logger.info(account)
                if is_in_list(account, temp_list):
                    not_end += 1
                    logger.debug(f"名字重复加:{not_end}")
                else:
                    temp_list.append(account)
                    info_list.append([account, self.tag_id])
            if info_list:
                # 写入数据库，
                self.database.insert_public_accounts(info_list)
            # if poco("com.tencent.mm:id/btz").exists:
            #     logger.debug("公众号界面，底部标识存在")
            #     label_text = poco("com.tencent.mm:id/btz").get_text()
            #     label_text.strip()
            #     logger.debug(label_text)
            #     break
            # pos_tuple = aip_list[0].center()
            # aip_list[-2].drag_to(*pos_tuple)
            # 当前界面的 信息行 小于 5行，说明已经到低，或者，本来就很少
            if len(aip_list) < 5:
                break
            self.wechat.swipe_to_top(aip_list)
        self.wechat.key_back()

    def get_one_business(self):
        """
        获取 企业微信好友 的 信息，
        :param poco:
        :return:
        """
        # TODO: 后续修改和get_one_friend 合并成一个方法，
        # 获取昵称，有可能不存在，需要先判断，
        # 昵称 nick_name
        # 备注名称： wx_alias
        logger.debug("进入 get_one_business")
        if self.wechat.friend_second_name.wait(timeout=3):
            nick_name = self.wechat.friend_second_name.get_text()
            # 昵称:  AA职工社保客服
            nick_name = nick_name[3:]
            nick_name = nick_name.strip()
            # poco("com.tencent.mm:id/bq1")
            wx_alias = self.wechat.friend_first_name.get_text()
            wx_alias = wx_alias.strip()
        else:
            # 获取 当前名字全称，有可能是备注的名字，  A0银行贷款雷学会18839391140
            nick_name = self.wechat.friend_first_name.get_text()
            nick_name = nick_name.strip()
            wx_alias = "空"
        # 公司名字，  例： ＠北京酷得少年科技

        if self.wechat.friend_company_name.wait(timeout=5):
            company = self.wechat.friend_company_name.get_text()
            if isinstance(company, str):
                company = company.strip()
            else:
                company = "空"
        else:
            company = "空"
        # 判断是否在职，# 1在职# 2离职# 0未知
        if self.wechat.friend_company_item.wait(timeout=3):
            active = 1
        elif self.wechat.friend_depart_item.wait(timeout=3):
            active = 2
        else:
            active = 0
        values = friend_info_dict.copy()
        values["nick_name"] = nick_name
        values["wx_alias"] = wx_alias
        values["company"] = company
        values["active"] = active
        values["tag_id"] = self.tag_id
        values["update_time"] = int(time.time())
        # logger.debug(f"get_one_business获取的信息:{info_list}")
        return values

    def get_friends_info(self):
        """
        普通微信好友，
        从微信通讯录中遍历 微信好友的信息，存入数据库，
        也可以更新数据库中的好友信息，
        :return:
        """
        # 进入 通讯录，
        self.wechat.navbar_book.click()
        # 第二次点击，复位到通讯录顶部
        self.wechat.navbar_book.click()
        while not self.wechat.book_friend_row.wait(timeout=3):
            self.wechat.swipe_up(0.6, 0.5)
        # 从数据库获取，当前微信号上的微信好友，
        friends_list_database = self.database.select_friends(self.tag_id)
        # 判断是否把通讯录 列表遍历完了，
        while True:
            # 获取的微信好友对象的列表
            friend_list = self.wechat.book_friend_row
            # 设置临时list存放数据，用于写入数据库，
            for friend in friend_list:
                # # 记录好右是否已经存在，
                # is_exists = False
                name_text = friend.get_text()
                name_text = deal_name_text(name_text)
                logger.debug(f"获取微信好友进度：{name_text}")
                if not self.wechat.is_clickable(friend):
                    logger.debug(f"当前元素不在可点击范围，跳过：{name_text}")
                    continue
                if name_text == "文件传输助手":
                    # 微信把文件助手 也当作好友放到了通讯录，
                    continue
                if is_in_list(name_text, friends_list_database):
                    continue
                friends_list_database.add(name_text)
                friend.click_gone()
                # 等待，让界面刷新稳定
                # time.sleep(self.back_wait_time)
                logger.debug("进入微信好友信息界面")
                info_dict = self.get_one_friend()
                self.wechat.key_back()
                time.sleep(self.back_wait_time)
                # 数据写入数据库
                self.database.insert_friend_info(info_dict)
            # 判断是否出现 结点 com.tencent.mm:id/bmm，，例
            if self.wechat.book_bottom_tip.wait(timeout=3):
                text_info = self.wechat.book_bottom_tip.get_text()
                logger.debug(f"当前微信共有：{text_info}")
                break
            self.wechat.swipe_up(0.8)

    def get_friends_info_slow(self):
        """
        此方法 废弃，

        普通微信好友，
        从微信通讯录中遍历 微信好友的信息，存入数据库，
        也可以更新数据库中的好友信息，
        :return:
        """
        # 进入 通讯录，
        self.wechat.navbar_book.click()
        # 第二次点击，复位到通讯录顶部
        self.wechat.navbar_book.click()
        while not self.wechat.book_friend_row.wait(timeout=3):
            self.wechat.swipe_up(0.5, 0.5)
        # 从数据库获取，当前微信号上的微信好友，
        friends_list_database = self.database.select_friends(self.tag_id)
        while True:
            # 获取的微信好友对象的列表
            friend_list = self.wechat.book_friend_row
            for friend in friend_list:
                name_text = friend.get_text()
                name_text = deal_name_text(name_text)
                logger.debug(f"获取微信好友进度：{name_text}")
                if not self.wechat.is_clickable(friend):
                    logger.debug(f"当前元素不在可点击范围，跳过：{name_text}")
                    continue
                if is_in_list(name_text, friends_list_database):
                    continue
                if name_text == "文件传输助手":
                    # 微信把文件助手 也当作好友放到了通讯录，
                    continue
                # friend.click()
                friend.click_gone()
                # for i in range(10):
                #     if self.wechat.friend_first_name.wait(timeout=3):
                #         break
                #     else:
                #         time.sleep(2)
                #         if self.wechat.friend_first_name.wait(timeout=3):
                #             break
                #         friend.click()
                #         logger.debug("没有进入 好友信息界面，再次点击")
                # else:
                #     logger.debug("重复巡视了10次，还没有发现")
                #     raise Exception("重复巡视了10次，还没有发现")
                # 等待一秒，让界面刷新稳定
                # time.sleep(1)
                info_dict = self.get_one_friend()
                self.wechat.key_back()
                time.sleep(0.5)
                # 记录数据
                logger.debug(info_dict)
                # 数据写入数据库
                self.database.insert_friend_info(info_dict)
            # 判断是否出现 结点 com.tencent.mm:id/bmm，，例
            if self.wechat.book_bottom_tip.wait(timeout=3):
                text_info = self.wechat.book_bottom_tip.get_text()
                logger.debug(f"当前微信共有：{text_info}")
                break
            logger.debug("向上滑动")
            self.wechat.swipe_up(0.8, 1.1)

    def get_business_friends(self):
        """
            # 获取企业好友的信息，
        # 先判断 企业微信联系人 标签是否存在 ，
        # 如果不存在，就向下划，
        # 如果当前通讯录界面，显示的不是顶部，再点一下通讯录，会回到顶部，
        # 或者是在标题栏上双击，
        # 记录循环次数，超过10次，就报错，

        :param poco:
        :param tag_id:
        :return:
        """
        # 进入 通讯录，
        self.wechat.navbar_book.click()
        # 第二次点击，复位到通讯录顶部
        self.wechat.navbar_book.click()
        # # 双击顶部，回到顶部
        # double_click()
        if not self.wechat.book_wxwork_friends.wait(timeout=3):
            logger.debug("本微信没有企业联系人")
            return
        # self.wechat.book_wxwork_friends.click()
        self.wechat.book_wxwork_friends.click_gone()
        # 判断是不是空的，
        if not self.wechat.wxwork_friends_items.wait(timeout=3):
            logger.debug("没有企业微信联系人，返回")
            self.wechat.key_back()
            self.wechat.navbar.wait(timeout=5.0)
            return
        # 从数据库获取，当前微信号上的微信好友，
        business_friends_db = self.database.select_business_friends(self.tag_id)
        # 企业微信好友，肯定不会很多，最多也就几十个，
        # 所以判断是否到底，就简单点，
        # 记录从屏幕获取的好友，重复的次数，
        # 判断是否把通讯录 列表遍历完了，长屏手机，每屏显示大约有14个左右的好友信息，
        # 遍历5次以上，也就是当repest_record大于30时，就说明已经到底了，
        repest_record = 0
        while repest_record < 30:
            friends_list = self.wechat.wxwork_friends_items
            for friend in friends_list:
                # 记录好右是否已经存在，

                name_text = friend.get_text()
                name_text = deal_name_text(name_text)
                logger.debug(f"获取企业好友进度：{name_text}")
                if not self.wechat.is_clickable(friend):
                    logger.debug(f"当前元素不在可点击范围，跳过：{name_text}")
                    continue
                if is_in_list(name_text, business_friends_db):
                    continue
                # 只要有新的名字，就归零，
                repest_record = 0
                business_friends_db.add(name_text)
                # friend.click()
                friend.click_gone()
                # time.sleep(self.back_wait_time)
                info_dict = self.get_one_business()
                self.database.insert_business_friends(info_dict)
                self.wechat.key_back()
                time.sleep(self.back_wait_time)
                self.wechat.swipe_up(0.9)
            # 如果整个界面 好友数量少于10个，直接跳出 while 循环，结束
            if 11 > len(friends_list):
                break
        # 整个循环结束，从企业微信联系人 界面，返回 通讯录 界面，
        self.wechat.key_back()

    def rooms_to_hide(self):
        """
        把微信群，折叠，
        :return:
        """
        # 点击 微信 进入信息流界面
        self.wechat.navbar_weixin.click()
        self.wechat.to_top()
        # 好友列表，
        friends_list_database = self.database.select_friends(self.tag_id)
        # 公众号列表，
        accounts_list_db = self.database.select_public_accounts(self.tag_id)
        # 企业微信好友列表
        business_friends_db = self.database.select_business_friends(self.tag_id)

        # # 群列表
        # rooms_list_db = select_rooms_info(self.tag_id)

        def is_in(name_text):
            # 判断 获取的 text ,是否是好友的名字，
            if is_in_list(name_text, friends_list_database):
                return True
            # 判断 获取的 text  是否是公众号，
            if is_in_list(name_text, accounts_list_db):
                return True
            # 判断 获取的 text 是否是企业好友，
            if is_in_list(name_text, business_friends_db):
                return True
            # 判断 获取的text 是否是微信功能，
            if is_in_list(name_text, self.other_list):
                return True
            if is_in_list(name_text, temp_list):
                return True
            return False

        # 上滑总数，只要有新增就 归零，
        swipe_count = 0
        temp_list = []
        is_exists = 0
        while swipe_count < 5:
            rows = self.wechat.table_rows
            # 判断当前屏幕，有没有新的微信群，
            for row in rows:
                name_text = row.get_text()
                name_text = deal_name_text(name_text)
                logger.debug(f"遍历进度：{name_text}")
                # 判断当前元素是否在可点击 范围，
                if not self.wechat.is_clickable(row):
                    logger.debug(f"当前元素不在可点击范围，跳过：{name_text}")
                    continue
                # 当名字不是群聊的时候 ，再判断类型，
                # 当名字是群聊，直接进行，
                if name_text != "群聊":
                    if is_in(name_text):
                        is_exists += 1
                        continue
                # 只要有新的元素就
                swipe_count = 0
                # 进入row，，
                # row.click_gone()
                # self.wechat.chat_interface_title.wait(timeout=self.back_wait_time)
                click_wait_for_appearance(row, self.wechat.chat_interface_title)
                room_name = self.wechat.chat_interface_title.get_text()
                room_name = deal_name_text(room_name)
                if self.room_is_exited():
                    continue
                if not is_rooms(room_name):
                    temp_list.append(room_name)
                    logger.debug(f"不是微信群-->{room_name}")
                    self.wechat.keyback_wait_for_appearance(self.wechat.share_title)
                    is_exists += 1
                    continue
                if is_in(name_text):
                    logger.debug(f"第2次判断，已经在列表中-->{room_name}")
                    self.wechat.keyback_wait_for_appearance(self.wechat.share_title)
                    is_exists += 1
                    continue
                # 进入聊天信息界面，
                self.wechat.chat_interface_info.click_gone()
                self.wechat.share_title.wait(timeout=self.back_wait_time)
                # title_text = poco("com.tencent.mm:id/ko4").get_text()
                # # 判断 标题中 是否包含 （）
                title_text = self.wechat.share_title.get_text()
                members_num = is_rooms(title_text)
                if not members_num:
                    temp_list.append(room_name)
                    logger.debug(f"不是微信群-->{room_name}")
                    self.wechat.key_back()
                    # 等待 更多信息 出现，
                    self.wechat.chat_interface_info.wait(timeout=5.0)
                    self.wechat.key_back()
                    self.wechat.share_title.wait(timeout=5.0)
                    is_exists += 1
                    # 返回到 信息流界面，并继续，
                    continue
                # 只要有新的元素就
                is_exists = 0
                temp_list.append(room_name)
                # # 获取 聊天 信息界面 的 群聊名称
                # name_text = poco("android:id/summary").get_text()
                logger.debug(f"群聊折叠进度：{room_name}")
                self.room_switch_save_tobook()
                self.room_fold()
                self.wechat.keyback_wait_for_appearance(self.wechat.chat_interface_title)
                self.wechat.key_back()
                time.sleep(self.back_wait_time)
                break
            logger.debug(f"is_exists=={is_exists}")
            if is_exists > 6:
                # pos_tuple = rows[0].center()
                # rows[-3].drag_to(*pos_tuple)
                # 在信息流界面，用 drag_to 起点点击 时，容易出现弹窗，
                # self.wechat.swipe_up(0.7, 0.5)
                self.wechat.swipe_to_top(rows)
                swipe_count += 1

    def room_quit(self):
        """
        退出已停用的群，
        例：、
        聊天界面上标提示：
        本群被用户投诉涉嫌违规，已被信用
        中间提示：
        群主“**”已解散该群聊
        下标提示：
        无法在已停用的群聊中发送消息
        :return:
        """
        # com.tencent.mm:id/b59
        # 无法在已停用的群聊中发送消息
        logger.debug("当前群已停用，操作退出")
        # self.wechat.chat_interface_info.click()
        self.wechat.chat_interface_info.click_gone()
        # 进入>聊天信息<界面
        # 判断是否出现 >备注<
        while not self.wechat.room_label_notes.wait(timeout=0.5):
            self.wechat.swipe_up(0.4, 0.4)
        # 判断是否 有备注名称，
        # 有备注 就更新数据库，
        if self.wechat.room_notes_text.wait(timeout=0.5):
            room_alias = self.wechat.room_notes_text.get_text()
            info_dict = update_room_state_dict.copy()
            info_dict["tag_id"] = self.tag_id
            info_dict["room_alias"] = room_alias
            info_dict["update_time"] = int(time.time())
            info_dict["update_time_text"] = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
            info_dict["status"] = 0
            self.database.update_room_state(info_dict)
        # 找<退出群聊> 按钮
        while not self.wechat.room_button_exit.wait(timeout=0.5):
            self.wechat.swipe_up(0.4, 0.3)
        self.wechat.room_button_exit.click()
        # 弹窗 提示 即将退出 并清空聊天记录，
        # self.wechat.room_popup_exit.wait(timeout=5).click()
        # click_wait_for_disappearance(self.wechat.room_popup_exit)
        # 这里的弹窗，应该是：
        # 清空聊天记录，并在聊天列表中删除。
        # 确定  com.tencent.mm:id/knx
        # 取消  com.tencent.mm:id/aq7

        # 这里的弹窗，应该是
        # 即将退出群聊"  ****  "
        # 清空聊天记录
        # 取消  退出
        # 这里的弹窗，还有可能是，
        # 清空聊天记录，并在聊天列表中删除，
        # 确定
        # 取消，
        if self.wechat.room_popup_del.wait(timeout=2):
            self.wechat.room_popup_del.click_gone()
        else:
            self.wechat.room_popup_exit.click_gone()
        # 回到信息流界面，

    def room_delete(self):
        """
        删除已退出的群
        无法在已退出的群聊中发送消息
        :return:
        """
        # com.tencent.mm:id/b59
        # 无法在已退出的群聊中发送消息
        logger.debug("当前群已退出或解散，操作删除")
        # self.wechat.chat_interface_info.click()
        self.wechat.chat_interface_info.click_gone()
        # 判断是否 有备注名称，
        if self.wechat.room_notes_text.wait(timeout=0.5):
            room_alias = self.wechat.room_notes_text.get_text()
            info_dict = update_room_state_dict.copy()
            info_dict["tag_id"] = self.tag_id
            info_dict["room_alias"] = room_alias
            info_dict["update_time"] = int(time.time())
            info_dict["update_time_text"] = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
            info_dict["status"] = 0
            self.database.update_room_state(info_dict)
        # 有备注 就更新数据库，
        # 删除按钮，
        while not self.wechat.room_button_exit.wait(timeout=0.5):
            self.wechat.swipe_up(0.4, 0.3)
        self.wechat.room_button_exit.click()
        # 点击 确定
        # self.poco("com.tencent.mm:id/knx").wait(timeout=5).click()
        if self.wechat.room_popup_del.wait(timeout=1):
            self.wechat.room_popup_del.click_gone()
        else:
            self.wechat.room_popup_exit.click_gone()

    def room_normal_quit(self, roomtype, count):
        """
        正常的群，退出流程
        主要用于退出拼车群，

        :return:
        """
        logger.debug("room_normal_quit 进入")
        info_dict = {
            "room_alias": "空",
            "room_name": "空",
            "roomid": "空",
            "roomowner_alias": "空",
            "roomowner_nick": "空",
            "roomowner_wxid": "空",
            "roomowner_area": "空",
            "roomtype": 0,
            "company": "空",
            "count": count,
            "tag_id": self.tag_id,
            "update_time": int(time.time()),
            "status": 0,
            "area": 0
        }
        if roomtype == 1:
            info_dict["roomtype"] = 1
        self.wechat.room_members.wait(timeout=5)
        # 默认获取第一个名称，就是群名称，
        room_name = self.wechat.room_notes_text.get_text()
        info_dict["room_name"] = deal_name_text(room_name)
        logger.debug(f"当前群名称为：{info_dict['room_name']}")
        info_dict["area"] = 1
        # if self.is_puyang(info_dict["room_name"]):
        #     logger.debug("群名称中包含濮阳关键字：{}".format(info_dict["room_name"]))
        #     info_dict["area"] = 1
        # puyang_count = 0
        # members_list = []
        # count_int = int(count)
        # for_num = 19
        # if count_int < 19:
        #     for_num = count_int
        # for i in range(for_num):
        logger.debug(f"获取群成员信息序列：{0}")
        self.wechat.room_members.wait(timeout=10)
        self.wechat.room_members[0].click_gone()
        #
        member_info = self.get_one_friend()
        logger.debug("当前群成员的区域：{}".format(member_info["area"]))
        # {
        # "nick_name": nick_name,
        # "wx_alias": wx_alias,
        # "wxid": wxid,
        # "area": area,
        # "tag_id": self.tag_id
        #         }
        # members_list.append(member_info)
        # self.wechat.key_back()
        # 回到群聊的 >聊天信息< 界面
        # self.wechat.share_title.wait(timeout=5.0)
        self.wechat.keyback_wait_for_appearance(self.wechat.share_title)
        # if "濮阳" in member_info["area"]:
        #     puyang_count += 1
        #     if i == 0:
        #         logger.debug("群主为濮阳的，判断为濮阳的群")
        #         break
        # if i == 0 and info_dict["area"] == 1:
        #     logger.debug("群名包含濮阳关键字，跳出循环")
        #     break
        # if puyang_count > 5:
        #     logger.debug(f"本群濮阳区成员共有数量：{puyang_count}")
        #     info_dict["area"] = 1
        #     break
        owner_dict = member_info
        info_dict["roomowner_alias"] = owner_dict["wx_alias"]
        info_dict["roomowner_nick"] = owner_dict["nick_name"]
        info_dict["roomowner_wxid"] = owner_dict["wxid"]
        info_dict["roomowner_area"] = owner_dict["area"]
        # if "濮阳" in owner_dict["area"]:
        #     # 群主为濮阳区域的，判断 群也是濮阳的，
        #     info_dict["area"] = 1
        # 获取群聊名称,
        # 判断 >群聊名称< 是否存在
        # 获取备注名称,
        # 判断 >备注< 是否存在 ,
        # for i in range(5):
        #     if self.wechat.room_label_notes.wait(timeout=3):
        #         break
        #     else:
        #         self.wechat.swipe_up(0.4, time=0.1)
        # else:
        #     raise Exception("上滑5次没有找到元素")
        # 如果是濮阳群，把备注修改，并更新数据库，
        # 把群成员的信息写入数据库，
        # 如果不是濮阳群，退出群聊，
        # name_list = self.wechat.room_notes_text
        # if info_dict["area"] == 1:
        #     logger.debug("当前微信群是否濮阳，是")
        #     # 判断为濮阳的群，
        #     notes = self.flag + "濮" + info_dict['room_name']
        #     # 点击 >备注< 选项
        #     # self.wechat.room_notes_empty.click()
        #     click_wait_for_appearance(self.wechat.room_label_notes, self.wechat.room_notes_editText)
        #     # 向输入框 写入，
        #     self.wechat.room_notes_editText.set_text(notes)
        #     # 点击 >完成<
        #     # self.wechat.room_notes_done.click()
        #     self.wechat.room_notes_done.click_gone()
        #     info_dict["room_alias"] = notes
        #     # # 返回，等待 群聊界面 右上角 >... 更多信息< 出现
        #     self.wechat.keyback_wait_for_appearance(self.wechat.chat_interface_info)
        #     self.wechat.keyback_wait_for_appearance(self.wechat.share_title)
        # else:
        # 判断为，不是濮阳的群，
        logger.debug("当前微信群是否濮阳，否")
        # 没有备注的写入t_rooms
        info_dict["room_alias"] = self.flag_rooms + "群" + info_dict['room_name']
        # 不是濮阳的群，在群状态设为 0
        info_dict["status"] = 0

        # 上划，找到<退出群聊> 按钮，
        # 找<退出群聊> 按钮
        # while not self.wechat.room_button_exit.exists():
        #     logger.debug("向上滑动，找<退出>按钮")
        #     self.wechat.swipe_up(0.4, 0.3)
        for i in range(10):
            logger.debug("向上滑动，找<退出>按钮")
            self.wechat.swipe_up(0.8, 0.3)
            if self.wechat.room_button_exit.exists():
                break
        # self.wechat.room_button_exit.click()
        click_wait_for_appearance(self.wechat.room_button_exit, self.wechat.room_popup_exit)
        # TODO:这里有可能出现 频繁提醒弹窗，以后补上判断，
        # 弹窗 提示 即将退出 并清空聊天记录，
        # self.wechat.room_popup_exit.wait(timeout=5).click()
        # click_wait_for_disappearance(self.wechat.room_popup_exit)
        # 这里的弹窗，应该是：
        # 清空聊天记录，并在聊天列表中删除。
        # 确定  com.tencent.mm:id/knx
        # 取消  com.tencent.mm:id/aq7
        click_wait_for_appearance(self.wechat.room_popup_exit, self.wechat.navbar)
        # 回到通讯录中的群聊标签，
        self.goto_book_rooms()
        # 写入数据库，
        self.database.insert_room_info(info_dict)
        # insert_room_members(info_dict['room_name'], members_list)

    def room_is_exited(self):
        """
        判断 是否已经被退群，
        或者当前群，是否已经停用，
        :return:
        """
        logger.debug("room_is_exited  进入")
        if self.wechat.chat_interface_edittext.wait(timeout=1):
            # 输入框  存在
            return False
        elif self.wechat.chat_interface_removed_tip.wait(timeout=0.5):
            tip = self.wechat.chat_interface_removed_tip.get_text()
            logger.debug(f"（第1次判断） 提示：{tip}")
            # 删除微信群，判断是已退出 ，还是已停用，
            # 退出或删除群聊，并写入数据库，
            if "退出" in tip or "解散" in tip:
                logger.info("当前微信群已经退出 或者 解散，现退出")
                self.room_delete()
            elif "停用" in tip:
                logger.info("当前微信群已经停用，现退出")
                self.room_quit()
            else:
                logger.debug("可能是公众号，返回并跳过 ")
                self.wechat.keyback_wait_for_appearance(self.wechat.share_title)
            # 被退出，或群停用，返回True
            return True
        else:
            return False

    def room_is_exited_second(self):
        """
        进入聊天信息界面后，判断 是否已经被退群，
        第2次判断
        :return:
        """
        title = self.wechat.share_title.get_text()
        count = is_rooms(title)
        logger.debug(f"群内总人数：{count}")
        if count:
            return count
        else:
            logger.debug(f"已被踢出微信群（第2次判断）:{title}")
            self.wechat.keyback_wait_for_appearance(self.wechat.chat_interface_title)
            self.wechat.key_back()
            return False

    def get_one_room(self, roomtype, count):
        """
        获取 单个微信群的 详细信息，
        :return:
        """
        # 需要获取 的信息，
        # room_alias	room_name	roomid
        # roomowner_alias	roomowner_nick	roomowner_wxid	roomower_area
        # roomtype
        # count	tag_id	update_time	status	area
        logger.debug("进入 get_one_room")
        area = 0
        if self.room_serialno is None:
            self.room_serialno = self.database.get_last_room_serialno(self.tag_id)
        self.room_serialno += 1

        # 获取群主的信息，
        self.wechat.room_members.wait(timeout=5)
        # self.wechat.room_owner.click()
        self.wechat.room_owner.click_gone()
        time.sleep(self.back_wait_time)
        if roomtype == 1:
            owner_dict = self.get_one_business()
        else:
            owner_dict = self.get_one_friend()
            if "濮阳" in owner_dict["area"]:
                area = 1
        self.wechat.key_back()
        # 回到群聊的 >聊天信息< 界面
        self.wechat.share_title.wait(timeout=5.0)
        # 获取群聊名称,
        # 判断 >群聊名称< 是否存在
        # 获取备注名称,
        # 判断 >备注< 是否存在 ,
        for i in range(5):
            if self.wechat.room_label_notes.wait(timeout=3):
                break
            else:
                self.wechat.swipe_up(0.4, time=0.5)
        else:
            raise Exception("上滑5次没有找到元素")

        name_list = self.wechat.room_notes_text
        if len(name_list) < 2:
            logger.debug("没有备注：")
            room_name = name_list.get_text()
            room_name = deal_name_text(room_name)
            base32_string = dec_to_base32(self.room_serialno)
            if area == 1 or self.is_puyang(room_name):
                # 判断为濮阳的群，
                logger.debug("群主是濮阳的，或者群名称中包含濮阳关键字：{}".format(room_name))

                room_alias = self.flag_rooms2 + base32_string + room_name
            else:

                room_alias = "群" + base32_string +room_name
            # 点击 >备注< 选项
            # self.wechat.room_notes_empty.click()
            click_wait_for_appearance(self.wechat.room_label_notes, self.wechat.room_notes_editText)
            # 向输入框 写入，
            self.wechat.room_notes_editText.set_text(room_alias)
            # 点击 >完成<
            # self.wechat.room_notes_done.click()
            self.wechat.room_notes_done.click_gone()
        else:
            room_name = self.wechat.room_notes_text[0].get_text()
            room_name = deal_name_text(room_name)
            room_alias = self.wechat.room_notes_text[1].get_text()
            area = 1
            # if info_dict["area"] == 0:
            #     if self.is_puyang(info_dict["room_name"]):
            #         logger.debug("群名称中包含濮阳关键字：{}".format(info_dict["room_name"]))
            #         info_dict["area"] = 1
        logger.info("执行进度{}".format(room_name))
        logger.debug("备注名称为：{}".format(room_alias))
        info_dict = room_info_dict.copy()
        info_dict["tag_id"] = self.tag_id
        info_dict["room_serialno"] = self.room_serialno
        info_dict["room_alias"] = room_alias
        info_dict["room_name"] = room_name
        info_dict["roomowner_alias"] = owner_dict["wx_alias"]
        info_dict["roomowner_nick"] = owner_dict["nick_name"]
        info_dict["roomowner_wxid"] = owner_dict["wxid"]
        info_dict["roomowner_area"] = owner_dict["area"]
        info_dict["roomtype"] = roomtype
        info_dict["company"] = owner_dict["company"]
        info_dict["members_total"] = count
        info_dict["update_time"] = int(time.time())
        info_dict["update_time_text"] = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
        info_dict["area"] = area

        # 写入数据库，
        self.database.insert_room_info(info_dict)
        return info_dict["room_alias"]

    def goto_book_rooms(self):
        """
        进入通讯录-群聊标签
        :return:
        """
        logger.debug("goto_book_rooms")
        # 进入 通讯录，
        self.wechat.navbar_book.click(timeout=8)
        # 第二次点击，复位到通讯录顶部
        self.wechat.navbar_book.click()
        self.wechat.navbar_book.click()
        # 点击 >群聊<
        # self.wechat.book_room.click()
        # click_wait_for_disappearance(self.wechat.book_room)
        click_wait_for_appearance(self.wechat.book_room, self.wechat.book_room_search)

    def get_rooms_info(self):
        """
        从通讯录的 群聊 标签中，遍历微信群，
        获取群信息，
        :param poco:
        :return:
        """
        logger.debug("get_rooms_info 进入")
        # 进入 通讯录，群聊
        self.goto_book_rooms()
        # 先判断 是否有群聊，如没有就返回，
        if self.wechat.book_bottom_tip.wait(timeout=3):
            logger.debug("群聊界面，底部标识存在，")
            if not self.wechat.book_room_rows.wait(timeout=3):
                logger.debug("群聊界面, 没有微信群，")
                return
        rooms_list_db = self.database.select_rooms_info(self.tag_id)
        temple_done = []
        # 屏幕上 大约能够显示 11 - 14 个微信群标签
        is_exists = 0
        # 底部  >  个群聊< 来
        while True:
            room_list = self.wechat.book_room_rows
            for room in room_list:
                try:
                    name_text = room.get_text(timeout=5)
                except Exception as e:
                    logger.error(e)
                    logger.error("row元素可能隐藏了，跳过，跳出for循环")
                    break
                name_text = deal_name_text(name_text)
                logger.debug(f"get_rooms_info执行进度：{name_text}")
                if is_in_list(name_text, rooms_list_db):
                    is_exists += 1
                    continue
                if is_in_list(name_text, temple_done):
                    is_exists += 1
                    continue
                temple_done.append(name_text)
                # 进入微信，
                click_wait_for_appearance(room, self.wechat.chat_interface_title)
                logger.debug("进入微信群聊天信息界面")
                name_text = self.wechat.chat_interface_title.get_text()
                roomtype = is_company_room(name_text)
                # 等待，让界面刷新稳定
                # time.sleep(self.back_wait_time)
                # # 第一次，判断 是不是在群内，是不是被踢了，
                # 先判断是否存在 》输入框《，这个判断效率更高，频次更高
                if self.room_is_exited():
                    is_exists += 1
                    # 退群，或 删群后，会回到基本页面，
                    self.goto_book_rooms()
                    # 跳出for 循环，
                    break
                # 进入聊天信息界面，
                click_wait_for_appearance(self.wechat.chat_interface_info, self.wechat.share_title)
                # 先判断 是不是在群内，是不是被踢了，
                # 判断 标题中有没有括号，
                # 判断 最下面的按钮文字 是不是 删除，
                # 是删除就， 获取备注名称，更新数据库，点击，删除，
                # 如果备注为空，则点击，删除，
                count = self.room_is_exited_second()
                if not count:
                    is_exists += 1
                    continue
                # 获取微信群的信息，
                room_alias = self.get_one_room(roomtype, count)
                temple_done.append(room_alias)
                is_exists = 0
                # # 获取 备注 名称
                # # 返回，等待 群聊界面 右上角 >... 更多信息< 出现
                self.wechat.keyback_wait_for_appearance(self.wechat.chat_interface_info)
                self.wechat.keyback_wait_for_appearance(self.wechat.share_title)
                # 每成功 运行一次，就结束，重头开始，
                break
            if is_exists > 15 and self.wechat.book_bottom_tip.wait(timeout=3):
                logger.debug("循环完成，底部标识存在，跳出while循环")
                # 跳出 while 循环
                break
            if len(room_list) < 10:
                logger.debug("页面rows 少于10个，跳出循环，")
                break
            if is_exists > 15:
                # pos_tuple = room_list[0].center()
                # room_list[-2].drag_to(*pos_tuple)
                self.wechat.swipe_to_top(room_list)
        # 返回 导航栏界面，
        self.wechat.key_back()

    def get_bookRooms_names(self):
        """
        获取通讯录-群聊，中的所有群名称，
        :return:
        """
        logger.debug("get_bookRooms_names 进入")
        # 存放获取的群名称，
        temple_done = set()
        # 进入 通讯录，群聊
        self.goto_book_rooms()
        # 先判断 是否有群聊，如没有就返回，
        if self.wechat.book_bottom_tip.wait(timeout=3):
            logger.debug("群聊界面，底部标识存在，")
            if not self.wechat.book_room_rows.wait(timeout=3):
                logger.debug("群聊界面, 没有微信群，")
                return temple_done
        # 屏幕上 大约能够显示 11 - 14 个微信群标签
        is_exists = 0
        # 底部  >  个群聊< 来
        while True:
            room_list = self.wechat.book_room_rows
            num = 0
            for room in room_list:
                num += 1
                name_text = room.get_text()
                name_text = deal_name_text(name_text)
                logger.debug(f"get_bookRooms_names：{name_text}")
                # if is_in_list(name_text, rooms_list_db):
                #     is_exists += 1
                #     continue
                if is_in_list(name_text, temple_done):
                    is_exists += 1
                    continue
                temple_done.add(name_text)
                is_exists = 0
            if is_exists > 16 and self.wechat.book_bottom_tip.wait(timeout=3):
                # 跳出 while 循环
                logger.debug("跳出 while 循环")
                break
            if len(room_list) < 10:
                logger.debug("get_bookRooms_names 页面元素少于10个，跳出循环")
                break
            # pos_tuple = room_list[0].center()
            # room_list[-2].drag_to(*pos_tuple)
            self.wechat.swipe_to_top(room_list)
        # 返回 导航栏界面，
        # self.wechat.key_back()
        self.wechat.keyback_homepage()
        return temple_done

    def goto_hidden_rooms(self):
        """
        进入--折叠的群聊 功能
        :return:
        """
        # 点击 微信底部导航栏的 <微信>
        self.wechat.navbar_weixin.click()
        # 点击 右上角 搜索框
        self.wechat.weixin_button_search.click()
        # 等待 输入框  出现
        self.wechat.weixin_input_box.wait(timeout=5)
        self.wechat.weixin_input_box.set_text("折叠的群聊")
        # 点击 <折叠的群聊>，
        # TODO:这里应该是需要判断一下的，判断元素的 name 是不是 折叠的群聊
        # self.wechat.weixin_search_results.wait(timeout=40)
        if self.wechat.weixin_search_results.wait(timeout=10):
            self.wechat.weixin_search_results.click_gone()

    def room_hide_saveTo_book(self):
        """
        把折叠起来的群，加入通讯录，
        TODO: 这个方法改为自动运行模式，
        :return:
        """
        logger.debug("room_hide_saveTo_book 进入")
        # rooms_list_db = self.get_bookRooms_names()
        self.goto_hidden_rooms()
        # 从数据库中获取已经加入通讯录的 群聊信息
        # 有可能产生判断失误，先不管了，
        # 每次运行前。先遍历通讯录中的 群聊标签，获取群名称，
        # rooms_list_db = select_rooms_info(self.tag_id)
        temple_done = []
        is_exists = 0
        is_swipe_up = 0
        while True:
            rooms = self.wechat.table_rows
            for room in rooms:
                name_text = room.get_text()
                name_text = deal_name_text(name_text)
                logger.debug(f"room_hide_saveTo_book执行进度：{name_text}")
                if is_in_list(name_text, temple_done):
                    is_exists += 1
                    continue
                temple_done.append(name_text)
                # 当有新的 row ,滑动计算归零，
                is_swipe_up = 0
                if self.flag_rooms in name_text:
                    # 有蛋窝标识 跳过，
                    is_exists += 1
                    continue
                # 点击 群聊标签
                # room.click_gone() 这个容易产生误操作，
                click_wait_for_appearance(room, self.wechat.chat_interface_info)
                # 进入 群 聊天界面，判断是否在群内，
                if self.room_is_exited():
                    is_exists += 1
                    # 退群，或 删群后，会回到基本页面，
                    self.goto_hidden_rooms()
                    # 跳出for 循环，
                    break
                name = self.wechat.chat_interface_title2.get_text()
                logger.debug(f"实际进入的群名称：{name}")
                if self.flag_rooms in name:
                    logger.debug("在聊天信息界面，判断，包含 蛋窝 ，返回")
                    # 有蛋窝标识 跳过，
                    is_exists += 1
                    self.wechat.key_back()
                    continue
                # # 进入聊天信息界面，
                # self.wechat.chat_interface_info.click(timeout=3)
                # # 等待，让界面刷新稳定
                # self.wechat.share_title.wait(timeout=3)
                click_wait_for_appearance(self.wechat.chat_interface_info, self.wechat.share_title)
                title = self.wechat.share_title.get_text()
                count = is_rooms(title)
                logger.debug(f"群内总人数：{count}")
                if not count:
                    logger.debug(f"已被踢出微信群（第2次判断）:{name_text}")
                    # TODO:获取 备注名称,,更新数据库
                    self.wechat.keyback_wait_for_appearance(self.wechat.chat_interface_title)
                    self.wechat.key_back()
                    is_exists += 1
                    continue
                # 有新的，重置为零，
                is_exists = 0
                while not self.wechat.room_label_saveToBook.wait(timeout=3):
                    self.wechat.swipe_up(0.6, 0.4)
                # 取消折叠，
                logger.debug("取消免打扰，取消折叠")
                # 判断 折叠 是否出现，
                self.room_unfold()
                # 点击 <保存到通讯录> 的按钮，有两种点击方式，
                self.room_switch_save_tobook()
                self.wechat.keyback_wait_for_appearance(self.wechat.chat_interface_title)
                self.wechat.keyback_wait_for_appearance(self.wechat.weixin_FoldedRooms_title)
                # 每进行一次，就从头开始，
                break
            if is_exists > 14:
                self.wechat.swipe_to_top(rooms)
                is_swipe_up += 1
            if is_swipe_up > 5:
                # 上滑 5次，还没有新的，说明到底了，跳出 while
                break
        # # 确定返回 信息流界面
        self.wechat.keyback_homepage()

    def auto_room_Unfold_saveTo_book(self, timeout):
        """
        把折叠起来的群，退出折叠判断是否已经加入通讯录，
        加入通讯录，
        :return:
        """
        logger.debug("room_Unfold_saveTo_book 进入")
        self.goto_hidden_rooms()
        deadline = time.time() + timeout
        while time.time() < deadline:
            if not self.wechat.table_rows.wait(timeout=6):
                logger.debug("已经取消所有的折叠，")
                self.flag_auto_room_Unfold_saveTo_book = 0
                break
            click_wait_for_appearance(self.wechat.table_rows, self.wechat.chat_interface_info)
            if self.room_is_exited():
                # 退群，或 删群后，会回到基本页面，
                self.goto_hidden_rooms()
                # 跳出for 循环，
                break
            name = self.wechat.chat_interface_title2.get_text()
            logger.debug(f"实际进入的群名称：{name}")

            click_wait_for_appearance(self.wechat.chat_interface_info, self.wechat.share_title)
            title = self.wechat.share_title.get_text()
            count = is_rooms(title)
            logger.debug(f"群内总人数：{count}")

            while not self.wechat.room_label_saveToBook.wait(timeout=3):
                self.wechat.swipe_up(0.6, 0.4)
            # 取消折叠，
            self.room_unfold()
            self.room_switch_save_tobook()
            self.wechat.keyback_wait_for_appearance(self.wechat.chat_interface_title)
            self.wechat.keyback_wait_for_disappearance(self.wechat.chat_interface_edittext)
        # # 确定返回 信息流界面
        self.wechat.keyback_homepage()

    def chatrooms_change_nickname(self):
        """
        更改在所有的群中的昵称，
        :return:
        """
        pass

    def init_user(self):
        """
        首次使用，初始化 微信数据 ，
        获取所有的微信数据，
        :param poco:
        :return:
        """
        self.get_public_accounts()
        self.get_business_friends()
        self.get_rooms_info()
        self.get_friends_info()

    def get_room_area(self, roomtype, count):
        """
        获取一个群的 地区信息，
        通过群成员的地区信息来分析，
        :return:
        """
        logger.debug("get_room_area 进入")
        status = 1
        # 从数据库获取serialno
        # 如果 self.room_serialno isnone ,从数据库获取最大的serialno
        # 如果 数据库中没有 serialno ,,,则默认为1
        # 以后 每次加1 并转换为 64进制字符串，
        if self.room_serialno is None:
            self.room_serialno = self.database.get_last_room_serialno(self.tag_id)
        self.room_serialno += 1

        self.wechat.room_members.wait(timeout=5)
        # 默认获取第一个名称，就是群名称，
        room_name = self.wechat.room_notes_text.get_text()
        room_name = deal_name_text(room_name)
        logger.debug(f"当前群名称为：{room_name}")
        area = 0
        if self.is_puyang(room_name):
            logger.debug("群名称中包含濮阳关键字：{}".format(room_name))
            area = 1
        puyang_count = 0
        members_list = []
        count_int = int(count)
        for_num = 19
        if count_int < 19:
            for_num = count_int
        for i in range(for_num):
            logger.debug(f"获取群成员信息序列：{i}")
            self.wechat.room_members.wait(timeout=10)
            self.wechat.room_members[i].click_gone()
            if i == 0 and roomtype == 1:
                member_info = self.get_one_business()
            else:
                member_info = self.get_one_friend()
            logger.debug("当前群成员的区域：{}".format(member_info["area"]))
            members_list.append(member_info)
            # 回到群聊的 >聊天信息< 界面
            self.wechat.keyback_wait_for_appearance(self.wechat.room_name_table)
            if "濮阳" in member_info["area"]:
                puyang_count += 1
                if i == 0:
                    area = 1
                    logger.debug("群主为濮阳的，判断为濮阳的群")
                    break
            if i == 0 and area == 1:
                logger.debug("群名包含濮阳关键字，跳出循环")
                break
            if puyang_count > 5:
                logger.debug(f"本群濮阳区成员共有数量：{puyang_count}")
                area = 1
                break

        # 获取群聊名称,
        # 判断 >群聊名称< 是否存在
        # 获取备注名称,
        # 判断 >备注< 是否存在 ,
        for i in range(5):
            if self.wechat.room_label_notes.wait(timeout=3):
                break
            else:
                self.wechat.swipe_up(0.4, time=0.2)
        else:
            raise Exception("上滑5次没有找到元素")
        # 如果是濮阳群，把备注修改，并更新数据库，
        # 把群成员的信息写入数据库，
        # 如果不是濮阳群，退出群聊，
        # name_list = self.wechat.room_notes_text
        if area == 1:
            logger.debug("当前微信群是否濮阳，是")
            # 判断为濮阳的群，
            base32_string = dec_to_base32(self.room_serialno)
            room_alias = self.flag_rooms2 + base32_string + room_name
            # 点击 >备注< 选项
            # self.wechat.room_notes_empty.click()
            click_wait_for_appearance(self.wechat.room_label_notes, self.wechat.room_notes_editText)
            # 向输入框 写入，
            self.wechat.room_notes_editText.set_text(room_alias)
            # 点击 >完成<
            # self.wechat.room_notes_done.click()
            self.wechat.room_notes_done.click_gone()
            # # 返回，等待 群聊界面 右上角 >... 更多信息< 出现
            self.wechat.keyback_wait_for_appearance(self.wechat.chat_interface_info)
            self.wechat.keyback_wait_for_appearance(self.wechat.share_title)
        else:
            # 判断为，不是濮阳的群，
            logger.debug("当前微信群是否濮阳，否")
            # 没有备注的写入t_rooms
            room_alias = "群" + room_name
            # 不是濮阳的群，在群状态设为 0
            status = 0
            # 上划，找到<退出群聊> 按钮，
            # 找<退出群聊> 按钮
            for i in range(10):
                logger.debug("向上滑动，找<退出>按钮")
                self.wechat.swipe_up(0.8, 0.3)
                if self.wechat.room_button_exit.exists():
                    break
            click_wait_for_appearance(self.wechat.room_button_exit, self.wechat.room_popup_exit)
            # TODO: 这里有可能出现 频繁提醒弹窗，以后补上判断，
            # 弹窗 提示 即将退出 并清空聊天记录，
            # self.wechat.room_popup_exit.wait(timeout=5).click()
            # click_wait_for_disappearance(self.wechat.room_popup_exit)
            # 这里的弹窗，应该是：
            # 清空聊天记录，并在聊天列表中删除。
            # 确定  com.tencent.mm:id/knx
            # 取消  com.tencent.mm:id/aq7
            click_wait_for_appearance(self.wechat.room_popup_exit, self.wechat.navbar)
            # 回到通讯录中的群聊标签，
            # TODO:为了增加通用性，这个地方要拿出去，
            self.goto_book_rooms()

        owner_dict = members_list[0]
        info_dict = room_info_dict.copy()
        info_dict["tag_id"] = self.tag_id
        info_dict["room_serialno"] = self.room_serialno
        info_dict["room_alias"] = room_alias
        info_dict["room_name"] = room_name
        info_dict["roomowner_alias"] = owner_dict["wx_alias"]
        info_dict["roomowner_nick"] = owner_dict["nick_name"]
        info_dict["roomowner_wxid"] = owner_dict["wxid"]
        info_dict["roomowner_area"] = owner_dict["area"]
        info_dict["roomtype"] = roomtype
        info_dict["company"] = owner_dict["company"]
        info_dict["members_total"] = count
        info_dict["update_time"] = int(time.time())
        info_dict["update_time_text"] = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
        info_dict["area"] = area
        info_dict["status"] = status
        # 写入数据库，
        self.database.insert_room_info(info_dict)
        self.database.insert_room_members(self.room_serialno, members_list)

    def temp_get_room_area(self, roomtype, count):
        """
        获取一个群的 地区信息，
        通过群成员的地区信息来分析，

        :return:
        """
        logger.debug("temp_get_room_area 进入")
        # 从数据库获取serialno
        # 如果 self.room_serialno isnone ,从数据库获取最大的serialno
        # 如果 数据库中没有 serialno ,,,则默认为1
        # 以后 每次加1 并转换为 32进制字符串，
        if self.room_serialno is None:
            self.room_serialno = self.database.get_last_room_serialno(self.tag_id)
        self.room_serialno += 1
        # 这里用copy,保证每次都是默认的值
        info_dict = room_info_dict.copy()
        self.wechat.room_members.wait(timeout=5)
        # 默认获取第一个名称，就是群名称，
        room_name = self.wechat.room_notes_text.get_text()
        room_name = deal_name_text(room_name)
        logger.debug(f"当前群名称为：{room_name}")
        logger.debug(f"获取群主信息")
        self.wechat.room_members.wait(timeout=10)
        self.wechat.room_members[0].click_gone()
        if roomtype == 1:
            member_info = self.get_one_business()
        else:
            member_info = self.get_one_friend()
        logger.debug("当前群成员的区域：{}".format(member_info["area"]))
        # 回到群聊的 >聊天信息< 界面
        self.wechat.keyback_wait_for_appearance(self.wechat.share_title)
        # 获取群聊名称,
        # 判断 >群聊名称< 是否存在
        # 获取备注名称,
        # 判断 >备注< 是否存在 ,
        for i in range(5):
            if self.wechat.room_label_notes.wait(timeout=3):
                break
            else:
                self.wechat.swipe_up(0.4, time=0.1)
        else:
            raise Exception("上滑5次没有找到元素")
        # 如果是濮阳群，把备注修改，并更新数据库，
        # 把群成员的信息写入数据库，
        # 如果不是濮阳群，退出群聊，
        # name_list = self.wechat.room_notes_text
        logger.debug("改备注")
        # 这里需要获取 room_serialno,
        # 把room_serialno 改为32进制字符串
        base64_string = dec_to_base32(self.room_serialno)
        room_alias = self.flag_rooms2 + base64_string + "-" + room_name
        # 点击 >备注< 选项
        # self.wechat.room_notes_empty.click()
        click_wait_for_appearance(self.wechat.room_label_notes, self.wechat.room_notes_editText)
        # 向输入框 写入，
        self.wechat.room_notes_editText.set_text(room_alias)
        # 点击 >完成<
        # self.wechat.room_notes_done.click()
        self.wechat.room_notes_done.click_gone()
        if not self.wechat.room_name_table.wait(timeout=2):
            # 先判断 标签 群聊名称是否存在，正常情况下这个频率更高，
            if self.wechat.room_notes_pop_tip.wait(timeout=1):
                # 判断 是否出现 弹窗了，
                tip = self.wechat.room_notes_pop_tip.get_text()
                logger.debug(f"弹窗提示：{tip}")
                self.wechat.room_notes_pop_button_ok.click()
                # # 返回，等待 群聊界面 右上角 >... 更多信息< 出现
                self.wechat.keyback_wait_for_appearance(self.wechat.chat_interface_info)
                self.wechat.keyback_wait_for_appearance(self.wechat.share_title)
                # 返回 0 ，不再执行后续操作，
                return 0

        # # 返回，等待 群聊界面 右上角 >... 更多信息< 出现
        self.wechat.keyback_wait_for_appearance(self.wechat.chat_interface_info)
        self.wechat.keyback_wait_for_appearance(self.wechat.share_title)
        owner_dict = member_info
        info_dict["tag_id"] = self.tag_id
        info_dict["room_serialno"] = self.room_serialno
        info_dict["room_alias"] = room_alias
        info_dict["room_name"] = room_name
        info_dict["roomowner_alias"] = owner_dict["wx_alias"]
        info_dict["roomowner_nick"] = owner_dict["nick_name"]
        info_dict["roomowner_wxid"] = owner_dict["wxid"]
        info_dict["roomowner_area"] = owner_dict["area"]
        info_dict["roomtype"] = roomtype
        info_dict["company"] = owner_dict["company"]
        info_dict["members_total"] = count
        info_dict["update_time"] = int(time.time())
        info_dict["update_time_text"] = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
        info_dict["area"] = 1
        # 写入数据库，
        self.database.insert_room_info(info_dict)
        return 1
        # insert_room_members(info_dict['room_name'], members_list)

    def get_rooms_area(self):
        """
        遍历，通讯录-群聊标签
        判断是否是濮阳的群，
        判断依据：遍历群成员前19个，
        濮阳地区的超过 4个，判断为濮阳的群，
        :return:
        """
        # 分析微信群的地区归属，
        logger.debug("get_rooms_area 进入")
        # 进入 通讯录，群聊
        self.goto_book_rooms()
        if not self.wechat.book_room_rows.wait(timeout=3):
            logger.debug("群聊界面, 没有微信群，")
            return
        while True:
            name_text = self.wechat.book_room_rows.get_text()
            name_text = deal_name_text(name_text)
            logger.debug(f"get_rooms_area执行进度：{name_text}")
            if self.flag_rooms2 in name_text:
                # 有 蛋窝 说明已经完成，
                logger.debug("get_rooms_area 已经完成，")
                break
            # TODO:通过关键字判断 拼车群，并退出
            # 拼车 巴豆 出行 网约车 顺风车 往返
            # 进入微信聊天界面，
            click_wait_for_appearance(self.wechat.book_room_rows, self.wechat.chat_interface_title)
            logger.debug("进入微信群聊天信息界面")
            roomtype = is_company_room(name_text)
            # # # 第一次，判断 是不是在群内，是不是被踢了，
            # # 先判断是否存在 》输入框《，这个判断效率更高，频次更高
            if self.room_is_exited():
                # 退群，或 删群后，会回到基本页面，
                self.goto_book_rooms()
                # 跳出for 循环，
                continue
            # 进入聊天信息界面，
            click_wait_for_appearance(self.wechat.chat_interface_info, self.wechat.share_title)
            count = self.room_is_exited_second()
            # 获取微信群地区的信息，
            self.get_room_area(roomtype, count)
        # 返回 首页，基本页面，
        self.wechat.keyback_homepage()

    def temp_get_rooms_area(self):
        """
        2023-9-3，修改所有的群的备注名称，
        :return:
        """
        # 分析微信群的地区归属，
        logger.debug("get_rooms_area 进入")
        # 进入 通讯录，群聊
        self.goto_book_rooms()
        # 先判断 是否有群聊，如没有就返回，
        if not self.wechat.book_room_rows.wait(timeout=3):
            logger.debug("群聊界面, 没有微信群，")
            return
        while True:
            if self.wechat.book_room_search.wait(timeout=2):
                click_wait_for_appearance(self.wechat.book_room_search, self.wechat.weixin_input_box)
            symbol = self.flag_rooms
            self.wechat.weixin_input_box.set_text(symbol)
            if self.wechat.book_room_rows.wait(timeout=5):
                name_text = self.wechat.book_room_rows.get_text()
                name_text = deal_name_text(name_text)
                logger.debug(f"temp_get_rooms_area：{name_text}")
                click_wait_for_appearance(self.wechat.book_room_rows, self.wechat.chat_interface_title)
                logger.debug("进入微信群聊天信息界面")
                name_text = self.wechat.chat_interface_title.get_text()
                roomtype = is_company_room(name_text)
                if self.room_is_exited():
                    # 退群，或 删群后，再进入 通讯录，群聊
                    self.goto_book_rooms()
                    continue
                # 进入聊天信息界面，
                click_wait_for_appearance(self.wechat.chat_interface_info, self.wechat.share_title)
                count = self.room_is_exited_second()
                # 获取微信群地区的信息，
                self.temp_get_room_area(roomtype, count)
            else:
                logger.debug("已经更改完成")
                # 返回 首页，基本页面，
                self.wechat.keyback_homepage()
                break

    def mass_message(self):
        """
        群发消息，更换发送方式，
        :return:
        """
        # 分析微信群的地区归属，
        logger.info("mass_message 进入")
        if self.task_id is None:
            # 如果 数据库中的群的数量 少于200个，就直接返回，不群发，
            rooms_total = self.database.get_user_rooms_total(self.tag_id)
            if rooms_total < settings.start_rooms_num:
                logger.debug("当前微信的群数量少于预设值，不执行群发任务，")
                return
            # 查询数据库中是否有 未完成的任务，
            # 任务状态（ 0未完成   1 已完成  2 手动完成）
            self.task_id, self.task_message, self.task_rooms = self.database.get_room_task(self.wxid, self.tag_id)
        # 进入 通讯录，群聊
        self.goto_book_rooms()
        while True:
            if len(self.task_rooms) < 1:
                # 所有的任务已经完成，更新 表 rooms_task
                task_info = update_rooms_tasks_info.copy()
                task_info["tag_id"] = self.tag_id
                task_info["task_id"] = self.task_id
                task_info["update_time"] = int(time.time())
                task_info["update_time_text"] = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
                task_info["status"] = 1
                self.database.update_rooms_tasks(task_info)
                # 返回 首页，基本页面，
                self.wechat.keyback_homepage()
                break
            logger.info("剩余任务数量：{}".format(len(self.task_rooms)))
            room_alias = self.task_rooms.pop()
            logger.info("本次发送的群聊：{}".format(room_alias))
            if self.wechat.book_room_search.wait(timeout=1):
                self.wechat.book_room_search.click()
            # room_alias 只要前10个字符，
            self.wechat.weixin_input_box.set_text(room_alias[:15])
            # 组装信息，
            record_info = task_record_info.copy()
            record_info["tag_id"] = self.tag_id
            record_info["task_id"] = self.task_id
            record_info["room_alias"] = room_alias
            record_info["update_time"] = int(time.time())
            record_info["update_time_text"] = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
            # 正常情况下，会自动出现 群row,
            if self.wechat.book_room_rows.wait(timeout=3):
                click_wait_for_appearance(self.wechat.book_room_rows, self.wechat.chat_interface_title)
                name_text = self.wechat.chat_interface_title.get_text()
                logger.debug(f"进入微信群聊天信息界面{name_text}")
                # roomtype = is_company_room(name_text)
                # # # 第一次，判断 是不是在群内，是不是被踢了，
                if self.room_is_exited():
                    # 更新，rooms_records,
                    record_info["status"] = 2
                    self.database.update_records(record_info)
                    # 从群中退出后，会回到信息流界面，
                    self.goto_book_rooms()
                    continue
                emos = random.sample(settings.emoji_list, 4)
                emos_string = ''.join(emos)
                message_text = self.task_message + emos_string

                self.wechat.chat_interface_edittext.set_text(message_text)
                self.wechat.chat_interface_send.click(timeout=3)
                self.wechat.keyback_wait_for_appearance2(self.wechat.book_room_search, self.wechat.book_room,
                                                         self.wechat.book_room_rows)
                record_info["status"] = 1
                self.database.update_records(record_info)
                # 返回 首页，基本页面，
                self.wechat.keyback_homepage(self.weinxinTest_default_waiting_time)
                # 第执行一次，就跳出
                break
            else:
                # 没有出现，说明此群已经退出了，更新数据库friendinfo.db,   表t_rooms
                logger.debug("没有找到群聊，")
                record_info["status"] = 2
                self.database.update_records(record_info)
                self.database.update_room_state(record_info)
                continue

    def select_option(self):
        """
        获取手动输入的选项，
        :return:
        """
        while True:
            print(f"品牌：{self.wechat.prop}")
            option = input("""
            1.初始化微信信息，
            2.分析微信群地域
            3.把群聊折叠
            4.自动运行
            5.删除缓存，
            6.修改所有的群的备注名称
            7.改好友的名字
            8.群取消折叠保存到通讯录
            9.批量获取朋友的信息
            10:

            请输入选项：""")
            if option.isdigit() and int(option) <= 10:
                break
            else:
                print("输入的字符不是整数")
                continue
        logger.debug(f"输入的选项：{option}")
        return int(option)

    # @deprecated(version='1.0', reason="This method is deprecated. Use new_method instead")
    # def change_notes(self):
    #     """
    #     临时使用的
    #     修改 已经获取过信息的备注名字，
    #     在备注前 添加，chr(0x10ffff)
    #     :return:
    #     """
    #     py_keys = ["濮6", "濮7", "濮8", "濮9", "濮5", "濮4", "濮3", "濮阳-"]
    #
    #     def is_puyangkey(name_text):
    #         """
    #         检测名字中是否包含 关键字，
    #         :param name_text:
    #         :return:
    #         """
    #         for key in py_keys:
    #             if key in name_text:
    #                 return True
    #         return False
    #
    #     def change_room_notes():
    #         """
    #         改变 群聊备注
    #         :return:
    #         """
    #         logger.debug("进入 change_room_notes")
    #         # 判断 >备注< 是否存在 ,
    #         for i in range(5):
    #             if self.wechat.room_label_notes.wait(timeout=3):
    #                 break
    #             else:
    #                 self.wechat.swipe_up(0.4, time=0.5)
    #         else:
    #             raise Exception("上滑5次没有找到元素")
    #         # 获取备注名称：
    #         room_alias = self.wechat.room_notes_text[1].get_text()
    #         # 点击备注
    #         # self.wechat.room_label_notes.click()
    #         click_wait_for_appearance(self.wechat.room_label_notes, self.wechat.room_notes_editText)
    #         notes = self.flag_rooms + room_alias
    #         # 向输入框 写入，
    #         self.wechat.room_notes_editText.set_text(notes)
    #         # 点击 >完成<
    #         # self.wechat.room_notes_done.click()
    #         self.wechat.room_notes_done.click_gone()
    #         logger.debug("备注名称为：{}".format(notes))
    #         # 写入数据库，
    #         self.database.update_room_alias(self.tag_id, room_alias, notes)
    #         return notes
    #
    #     logger.debug("change_notes 进入")
    #     # 进入 通讯录，群聊
    #     self.goto_book_rooms()
    #     # 先判断 是否有群聊，如没有就返回，
    #     if self.wechat.book_bottom_tip.wait(timeout=3):
    #         logger.debug("群聊界面，底部标识存在，")
    #         if not self.wechat.book_room_rows.wait(timeout=3):
    #             logger.debug("群聊界面, 没有微信群，")
    #             return
    #     # rooms_list_db = select_rooms_info(self.tag_id)
    #     temple_done = []
    #     # 屏幕上 大约能够显示 11 - 14 个微信群标签
    #     is_exists = 0
    #     # 底部  >  个群聊< 来
    #     while True:
    #         room_list = self.wechat.book_room_rows
    #         for room in room_list:
    #             name_text = room.get_text()
    #             name_text = deal_name_text(name_text)
    #             logger.debug(f"gchange_notes执行进度：{name_text}")
    #             # if is_in_list(name_text, rooms_list_db):
    #             #     is_exists += 1
    #             #     continue
    #             if self.flag_rooms in name_text:
    #                 is_exists += 1
    #                 continue
    #             if is_in_list(name_text, temple_done):
    #                 is_exists += 1
    #                 continue
    #             temple_done.append(name_text)
    #             if not is_puyangkey(name_text):
    #                 is_exists += 1
    #                 continue
    #             click_wait_for_appearance(room, self.wechat.chat_interface_title)
    #             logger.debug("进入微信群聊天信息界面")
    #             name_text = self.wechat.chat_interface_title.get_text()
    #             # roomtype = is_company_room(name_text)
    #             # 等待，让界面刷新稳定
    #             # time.sleep(self.back_wait_time)
    #             # # 第一次，判断 是不是在群内，是不是被踢了，
    #             # 先判断是否存在 》输入框《，这个判断效率更高，频次更高
    #             if self.room_is_exited():
    #                 is_exists += 1
    #                 # 退群，或 删群后，会回到基本页面，
    #                 self.goto_book_rooms()
    #                 # 跳出for 循环，
    #                 break
    #             # 进入聊天信息界面，
    #             click_wait_for_appearance(self.wechat.chat_interface_info, self.wechat.share_title)
    #             # 先判断 是不是在群内，是不是被踢了，
    #             # 判断 标题中有没有括号，
    #             # 判断 最下面的按钮文字 是不是 删除，
    #             # 是删除就， 获取备注名称，更新数据库，点击，删除，
    #             # 如果备注为空，则点击，删除，
    #             count = self.room_is_exited_second()
    #             if not count:
    #                 is_exists += 1
    #                 continue
    #             # 获取微信群的信息，
    #             room_alias = change_room_notes()
    #             temple_done.append(room_alias)
    #             is_exists = 0
    #             # # 获取 备注 名称
    #             # # 返回，等待 群聊界面 右上角 >... 更多信息< 出现
    #             self.wechat.keyback_wait_for_appearance(self.wechat.chat_interface_info)
    #             self.wechat.keyback_wait_for_appearance(self.wechat.share_title)
    #             # 每成功 运行一次，就结束，重头开始，
    #             break
    #         if is_exists > 15 and self.wechat.book_bottom_tip.wait(timeout=3):
    #             logger.debug("循环完成，底部标识存在，跳出while循环")
    #             # 跳出 while 循环
    #             break
    #         if len(room_list) < 10:
    #             logger.debug("页面rows 少于10个，跳出循环，")
    #             break
    #         if is_exists > 15:
    #             # pos_tuple = room_list[0].center()
    #             # room_list[-2].drag_to(*pos_tuple)
    #             self.wechat.swipe_to_top(room_list)
    #     # 返回 导航栏界面，
    #     self.wechat.key_back()

    def clean_rcoard(self):
        """
        清除微信记录，释放手机空间，
        :return:
        """
        # 等待时间，60分钟
        wait_out = 60 * 60
        sleep_time = 5
        # 点 我
        self.clicks(self.wechat.pro_navbar_me)
        # 点设置
        self.wechat.me_settings.click()
        # 通用
        self.wechat.settings_universal.click(timeout=5)
        # 存储空间
        self.wechat.settings_storage_space.click(timeout=5)
        # 第一步，清理缓存
        # 等待 微信计算，最长为 设置为 30分钟，
        # 判断 缓存-前往清理 是否存在，
        start = time.time()
        while not self.wechat.settings_goto_clear.wait(timeout=3):
            time.sleep(sleep_time)
            if time.time() - start > wait_out:
                raise Exception('超时，检查')
            if self.wechat.settings_all_space.wait(timeout=3):
                tip = self.wechat.settings_all_space.get_text()
                logger.info(tip)
        # 一般，都是先计算完 缓存，
        cache_count = self.wechat.settings_cache_count.get_text()
        logger.info(f"缓存是：{cache_count}")
        # 出现缓存数据，出现按钮<前往清理>
        self.wechat.settings_goto_clear.click()
        # 点击 清理 按钮
        self.wechat.settings_cache_clear.click(timeout=8)
        # 出现弹窗
        # 内容：清理缓存可能需要一些时间，清理过程中请耐心等候。
        # 按钮：清理
        # self.wechat.settings_cache_popup_clear.click(timeout=5)
        self.clicks(self.wechat.pro_settings_cache_popup_clear)
        # 等待出现：tip:没有可清理的内容
        self.wechat.settings_cache_tips.wait(timeout=60)
        # 退出当前页面，
        self.wechat.key_back()
        # 第二步 清理聊天记录
        # 等待 按钮 管理 出现
        start = time.time()
        while not self.wechat.settings_records_manage.wait(timeout=3):
            time.sleep(sleep_time)
            if time.time() - start > wait_out:
                raise Exception('超时，检查')
            if self.wechat.settings_records_count.wait(timeout=3):
                tip = self.wechat.settings_records_count.get_text()
                logger.info(f"聊天记录运行：{tip}")
        # 点击 按钮 管理
        self.wechat.settings_records_manage.click()
        # 聊天记录计算时间最长，
        # 刚开始，只有旋转图标，
        # 出现 正在计算 百分比，
        # 当计算完成 出现数据 出现按钮<管理>
        # 等待微信 计算，
        start = time.time()
        while not self.wechat.settings_records_rows.wait(timeout=3):
            time.sleep(sleep_time)
            if time.time() - start > wait_out:
                raise Exception('聊天记录管理页面，超时，检查')
            if self.wechat.settings_records_loading.wait(timeout=3):
                tip = self.wechat.settings_records_loading.get_text()
                logger.info(tip)
        # 遍历所有的rows，并写入数据库，
        current_datetime = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
        # 存放数据 ，最后写入 数据库
        info_dict_list = []
        # 存放群名称，用来判断 运行进度，和跳出时机，
        temp_set = set()
        is_exists = 0
        num = 0
        # 只要前50个群的 空间数据 ，
        # 如果 rows 过少，就以重复30次判断 ，
        n = 0
        while num < 30 and is_exists < 30:
            rows = self.wechat.settings_records_rows
            for row in rows:
                if n > 7:
                    # 在本页面只遍历 8个，超过8个容易报错
                    break
                n += 1
                if not row.wait(timeout=2):
                    continue
                room_name = row.get_text()
                room_name = deal_name_text(room_name)
                if is_in_list(room_name, temp_set):
                    is_exists += 1
                    logger.debug(f"is_end:{is_exists}")
                    continue
                is_exists = 0
                if row.sibling(resourceId=self.wechat.text_settings_records_rows_count).wait(timeout=3):
                    count = row.sibling(resourceId=self.wechat.text_settings_records_rows_count).get_text()
                    logger.info(f"占用空间：{count}")
                else:
                    # 没有显示出来 空间数据，则跳过
                    continue
                num += 1
                logger.info(f"遍历进度：{num}--{room_name}")
                temp_set.add(room_name)
                row_dict = {
                    "tag_id": self.tag_id,
                    "room_name": room_name,
                    "count": count,
                    "update_time": current_datetime
                }
                info_dict_list.append(row_dict)
            n = 0
            # pos_tuple = rows[0].center()
            # rows[-1].drag_to(*pos_tuple)
            self.wechat.swipe_to_top(rows)
        # 写入数据库，
        self.database.insert_rooms_records(info_dict_list)
        # 点 全选，
        # 点击全选后，当前元素的text 变为 取消全靠，如果点击不稳定，可以此为判断
        self.wechat.settings_records_selectAll.click()
        # 点击 清理
        self.wechat.settings_records_clear.click()
        # 这里会 出现不同的弹窗，
        # 情况一：
        # 弹窗=>
        # 清理所选范围内的图片、视频和文件
        # 你可以在聊天上下文中继续看到这些消息，但是它们无法被打开。
        #
        # 清理后，将剩余 9.3 GB 的聊天记录，主要包括文字、语音和表情等。
        # 取消    清理 (392 KB)
        if self.wechat.settings_records_delete_cache.wait(timeout=1):
            # 第一次清理的还是缓存，
            logger.info("再清理缓存")
            self.wechat.settings_records_delete_cache.click()
            self.wechat.room_popup_del.click(timeout=2)
            # 浮窗
            # 正在删除: 100%
            start = time.time()
            while self.wechat.settings_records_deleting.wait(timeout=10):
                tips = self.wechat.settings_records_deleting.get_text()
                logger.debug(tips)
                time.sleep(sleep_time)
                if time.time() - start > wait_out:
                    raise Exception('正在删除，超时，检查')
        # 情况二：
        # 点击全选后，当前元素的text 变为 取消全靠，如果点击不稳定，可以此为判断
        self.wechat.settings_records_selectAll.click_exists(timeout=1)
        # 点击 清理
        self.wechat.settings_records_clear.click_exists(timeout=1)
        # 弹窗=>
        # 所选范围内无可清理的图片、视频或文件
        # 所选范围还剩余 93.9 MB 的聊天记录，包括文字、语音、表情等。
        # 【我知道了】
        # <删除所选范围内剩余的聊天记录>
        self.wechat.settings_records_clearAll.click(timeout=10)
        # 弹窗=>
        # 删除所选范围内剩余的聊天记录
        # 剩余的聊天记录主要包括文字、语音和表情等。
        # 按钮< 删除 (93.9 MB)>
        self.wechat.settings_records_delete.click(timeout=10)
        # 弹窗=>
        # 删除后不可恢复，确定删除？
        # 按钮<删除>
        logger.debug("点击 删除")
        self.wechat.settings_records_delete2.click(timeout=10)
        start = time.time()
        while self.wechat.settings_records_deleting.wait(timeout=10):
            tip = self.wechat.settings_records_deleting.get_text()
            logger.debug(tip)
            time.sleep(sleep_time)
            if time.time() - start > wait_out:
                raise Exception('正在删除，超时，检查')
        # TODO: 删除完成后，还是停留在当前页面，最后返回，
        # 返回到页面   存储空间 页面
        self.wechat.keyback_wait_for_appearance(self.wechat.settings_storage_space_title)
        # 返回到页面  通用
        self.wechat.keyback_wait_for_appearance(self.wechat.settings_universal_title)
        # 返回到页面  设置
        self.wechat.keyback_wait_for_appearance(self.wechat.me_settings_title)
        self.wechat.key_back()

    def del_some_rooms(self):
        """
        遍历删除 拼车群，等等，广告群，
        # 拼车 巴豆 出行 网约车 顺风车 往返 顺路
        :return:
        """
        keywords = '拼车,巴豆,出行,网约车,顺风车,往返,顺路'
        keywords_list = keywords.split(",")
        logger.debug("删除拼车群")

        def is_in_name(name_text, keywords_list):
            for key in keywords_list:
                if key in name_text:
                    return True
                return False

        # 进入 通讯录，群聊
        self.goto_book_rooms()
        # 先判断 是否有群聊，如没有就返回，
        if self.wechat.book_bottom_tip.wait(timeout=3):
            logger.debug("群聊界面，底部标识存在，")
            if not self.wechat.book_room_rows.wait(timeout=3):
                logger.debug("群聊界面, 没有微信群，")
                return
        num = 0
        total = len(keywords_list)
        while num < total:
            key = keywords_list[num]
            # 点击群聊界面的搜索框，
            self.wechat.book_room_search.click(timeout=1)
            # 输入关键字，
            self.wechat.weixin_input_box.set_text(key)
            # 判断 是否 有结果
            if self.wechat.book_room_rows.wait(timeout=5):
                logger.debug("搜索有结果")
                # 点击第1项row,
                # self.wechat.book_room_rows[0].click(timeout=2)
                click_wait_for_appearance(self.wechat.book_room_rows[0], self.wechat.chat_interface_title)
                # 进入群聊天界面，
                # 判断 是否 已经被 退出 ，或者，群已经停用，
                if self.room_is_exited():
                    # 重新进入   通讯录->群聊
                    self.goto_book_rooms()
                    continue
                # 进入群 聊天信息界面，
                logger.debug("进入微信群聊天信息界面")
                name_text = self.wechat.chat_interface_title.get_text()
                roomtype = is_company_room(name_text)
                # 点击 右上角 ...，
                # 进入聊天信息界面，
                click_wait_for_appearance(self.wechat.chat_interface_info, self.wechat.share_title)
                count = self.room_is_exited_second()
                # 退出群聊，
                self.room_normal_quit(roomtype, count)
                # 每成功 运行一次，就结束，重头开始，
            else:
                num += 1
                continue
        self.wechat.keyback_homepage()

    def temp_get_one_friend(self):
        """
        在微信好友 详情界面获取信息，
        :param poco:
        :return:
        """
        # 获取昵称，有可能不存在，需要先判断，
        # 昵称 nick_name
        # 备注名称： wx_alias
        logger.debug("进入 temp_get_one_friend")
        self.wechat.friend_first_name.wait(timeout=3)
        if self.wechat.friend_second_name.wait(timeout=0.5):
            logger.debug("有备注名称")
            nick_name = self.wechat.friend_second_name.get_text()
            # 昵称:  AA职工社保客服
            nick_name = nick_name[3:]
            nick_name = nick_name.strip()
            nick_name = deal_name_text(nick_name)
            # wx_alias = self.wechat.friend_first_name.get_text()
            # wx_alias = wx_alias.strip()
            # wx_alias = deal_name_text(wx_alias)
        else:
            # 获取 当前名字全称，有可能是备注的名字，  A0银行贷款雷学会18839391140
            logger.debug("没有备注名称")
            # wx_alias = "空"
            if self.wechat.friend_first_name.wait(timeout=0.5):
                nick_name = self.wechat.friend_first_name.get_text()
                nick_name = nick_name.strip()
                nick_name = deal_name_text(nick_name)
            else:
                logger.debug("没有任何名字")
                nick_name = "空"
        # 获取微信号  例： 微信号:  wxid_xe7splotqru922
        if self.wechat.friend_wxid.wait(timeout=0.5):
            wxid = self.wechat.friend_wxid.get_text()
            wxid = wxid[4:]
            wxid = wxid.strip()
        else:
            wxid = "空"
        # 获取 地区信息，有可能不存在，需要判断，，例：地区:  河南  濮阳
        if self.wechat.friend_area.wait(timeout=0.5):
            area = self.wechat.friend_area.get_text()
            area = area[3:]
            area = area.strip()
        else:
            area = "空"

        # TODO: 设备备注名称，
        # 从数据库获取最后一个id,加1，转换为base32,
        # 点击进入，保存，
        if self.friend_serialno is None:
            self.friend_serialno = self.database.get_last_friend_serialno(self.tag_id)
        self.friend_serialno += 1
        self.wechat.set_notes.click()
        self.wechat.text_view_notes.click()
        base32_string = dec_to_base32(self.friend_serialno)
        wx_alias = self.flag_friend + base32_string + "-" + nick_name
        self.wechat.edit_text_notes.set_text(wx_alias)
        click_wait_for_appearance(self.wechat.button_done, self.wechat.friend_first_name)
        values = friend_info_dict.copy()
        values["nick_name"] = nick_name
        values["friend_serialno"] = self.friend_serialno
        values["wx_alias"] = wx_alias
        values["wxid"] = wxid
        values["area"] = area
        values["tag_id"] = self.tag_id
        values["update_time"] = int(time.time())
        # logger.debug(f"get_one_friend 获取的 信息：{values}")
        return values

    def temp_get_friends_info_slow(self):
        """

        临时方法，把所有的好友的名字，都改备注，做到唯一性，，方法识别，
        :return:
        """
        # 进入 通讯录，
        self.wechat.navbar_book.click()
        # 第二次点击，复位到通讯录顶部
        self.wechat.navbar_book.click()
        while not self.wechat.book_friend_row.wait(timeout=3):
            self.wechat.swipe_up(0.5, 0.5)
        # # 从数据库获取，当前微信号上的微信好友，
        # friends_list_database = select_friends(self.tag_id)
        i = 0
        while True:
            # 获取的微信好友对象的列表
            friend = self.wechat.book_friend_row[i]
            if not friend.wait(timeout=5):
                self.wechat.swipe_up(0.3, 0.5)
                continue
            name_text = friend.get_text()
            # print(name_text)
            if not self.wechat.is_clickable(friend):
                self.wechat.swipe_up(0.3, 0.5)
                logger.debug(f"当前元素不在可点击范围，跳过：{name_text}")
                continue
            if self.flag_friend in name_text:
                # 遍历结束
                break
            if name_text == "文件传输助手":
                # 微信把文件助手 也当作好友放到了通讯录，
                i += 1
                continue
            if name_text == "微信团队":
                # 微信把文件助手 也当作好友放到了通讯录，
                i += 1
                continue
            if self.nick_name in name_text:
                # 微信把 自己也放到了通讯录，
                i += 1
                continue
            name_text = deal_name_text(name_text)
            logger.debug(f"获取微信好友进度：{name_text}")
            click_wait_for_appearance(friend, self.wechat.friend_first_name)
            # 等待一秒，让界面刷新稳定
            info_dict = self.temp_get_one_friend()
            time.sleep(0.5)
            self.wechat.keyback_homepage()
            # 数据写入数据库
            self.database.insert_friend_info(info_dict)

    def auto_change_friends_note(self, timeout):
        """

        自动运行方法，把所有的好友的名字，都改备注，做到唯一性，，方法识别，
        :param timeout 执行的时长，
        :return:
        """
        logger.debug("auto_change_friends_not")
        # 判断这个功能是否要执行，
        # 进入 通讯录，
        self.wechat.navbar_book.click()
        # 第二次点击，复位到通讯录顶部
        self.wechat.navbar_book.click()
        while not self.wechat.book_friend_row.wait(timeout=3):
            self.wechat.swipe_up(0.5, 0.5)
        # # 从数据库获取，当前微信号上的微信好友，
        # friends_list_database = select_friends(self.tag_id)
        i = 0
        deadline = time.time() + timeout
        while time.time() < deadline:
            # 获取的微信好友对象的列表
            friend = self.wechat.book_friend_row[i]
            if not friend.wait(timeout=5):
                self.wechat.swipe_up(0.3, 0.5)
                continue
            name_text = friend.get_text()
            logger.debug(f"当前好友名称：{name_text}")
            if not self.wechat.is_clickable(friend):
                self.wechat.swipe_up(0.3, 0.5)
                logger.debug(f"当前元素不在可点击范围，跳过：{name_text}")
                continue
            if self.flag_friend in name_text:
                # 遍历结束
                logger.debug("auto_change_friends_note 已经完成")
                self.flag_change_friends_notes = 0
                break
            if name_text == "文件传输助手":
                # 微信把文件助手 也当作好友放到了通讯录，
                i += 1
                continue
            if name_text == "微信团队":
                # 微信把文件助手 也当作好友放到了通讯录，
                i += 1
                continue
            if self.nick_name in name_text:
                # 微信把 自己也放到了通讯录，
                i += 1
                continue
            name_text = deal_name_text(name_text)
            logger.debug(f"获取微信好友进度：{name_text}")
            click_wait_for_appearance(friend, self.wechat.friend_first_name)
            # 等待一秒，让界面刷新稳定
            info_dict = self.temp_get_one_friend()
            time.sleep(1)
            self.wechat.keyback_homepage()
            # 数据写入数据库
            self.database.insert_friend_info(info_dict)
            time.sleep(1)

    def auto_get_rooms_area(self, timeout):
        """
        遍历，通讯录-群聊标签
        判断是否是濮阳的群，
        判断依据：遍历群成员前19个，
        濮阳地区的超过 4个，判断为濮阳的群，
        :return:
        """
        # 分析微信群的地区归属，
        logger.debug(">>>>>>auto_get_rooms_area 进入")
        # 进入 通讯录，群聊
        self.goto_book_rooms()
        if not self.wechat.book_room_rows.wait(timeout=3):
            logger.debug("群聊界面, 没有微信群，")
            return
        deadline = time.time() + timeout
        while time.time() < deadline:
            name_text = self.wechat.book_room_rows.get_text()
            name_text = deal_name_text(name_text)
            logger.debug(f"auto_get_rooms_area执行进度：{name_text}")
            if self.flag_rooms2 in name_text:
                # 有 蛋窝 说明已经完成，
                logger.debug("auto_get_rooms_area已经完成，")
                self.flag_auto_get_rooms_area = 0
                break
            # TODO:通过关键字判断 拼车群，并退出
            # 拼车 巴豆 出行 网约车 顺风车 往返
            # 进入微信聊天界面，
            click_wait_for_appearance(self.wechat.book_room_rows, self.wechat.chat_interface_title)
            logger.debug("进入微信群聊天信息界面")
            roomtype = is_company_room(name_text)
            # # # 第一次，判断 是不是在群内，是不是被踢了，
            # # 先判断是否存在 》输入框《，这个判断效率更高，频次更高
            if self.room_is_exited():
                # 退群，或 删群后，会回到基本页面，
                self.goto_book_rooms()
                # 跳出for 循环，
                continue
            # 进入聊天信息界面，
            click_wait_for_appearance(self.wechat.chat_interface_info, self.wechat.share_title)
            count = self.room_is_exited_second()
            # 获取微信群地区的信息，
            self.get_room_area(roomtype, count)
        # 返回 首页，基本页面，
        self.wechat.keyback_homepage()

    def auto_change_rooms_notes(self, timeout):
        """
        2023-9-3，修改所有的群的备注名称，
        :return:
        """
        # 分析微信群的地区归属，
        logger.debug("auto_change_rooms_notes 进入")
        # 进入 通讯录，群聊
        self.goto_book_rooms()
        # 先判断 是否有群聊，如没有就返回，
        if not self.wechat.book_room_rows.wait(timeout=3):
            logger.debug("群聊界面, 没有微信群，")
            return
        deadline = time.time() + timeout
        while time.time() < deadline:
            if self.wechat.book_room_search.wait(timeout=2):
                click_wait_for_appearance(self.wechat.book_room_search, self.wechat.weixin_input_box)
            symbol = self.flag_rooms
            self.wechat.weixin_input_box.set_text(symbol)
            if self.wechat.book_room_rows.wait(timeout=5):
                name_text = self.wechat.book_room_rows.get_text()
                name_text = deal_name_text(name_text)
                logger.debug(f"temp_get_rooms_area：{name_text}")
                click_wait_for_appearance(self.wechat.book_room_rows, self.wechat.chat_interface_title)
                logger.debug("进入微信群聊天信息界面")
                name_text = self.wechat.chat_interface_title.get_text()
                roomtype = is_company_room(name_text)
                if self.room_is_exited():
                    # 退群，或 删群后，再进入 通讯录，群聊
                    self.goto_book_rooms()
                    continue
                # 进入聊天信息界面，
                click_wait_for_appearance(self.wechat.chat_interface_info, self.wechat.share_title)
                count = self.room_is_exited_second()
                # 获取微信群地区的信息，
                result = self.temp_get_room_area(roomtype, count)
                if not result:
                    self.flag_auto_change_rooms_notes = result
                    break
            else:
                logger.debug("已经更改完成")
                self.flag_auto_change_rooms_notes = 0
                # 返回 首页，基本页面，
                break
        self.wechat.keyback_homepage()

    def determine_interface(self):
        """
        进入聊天界面后，判断当前界面的是什么功能

        :return:
        """
        logger.debug("判断当前界面是什么功能：")
        if self.wechat.subscription_account.wait(timeout=3):
            # 订阅号标题存在，
            logger.debug("当前界面是--微信的功能：订阅号标")
            return 1
        title_text = self.wechat.chat_interface_title_common.get_text()
        title_text = title_text.strip()
        # 主要分三种，1，微信的功能，2，好友，3，微信群， 4,未知，

        if is_homepage(title_text):
            logger.debug("当前是信息流界面")
            return 9
        if is_in_list(title_text, self.other_list):
            # 是微信的功能，
            logger.debug(f"当前界面是--微信的功能：{title_text}")
            return 1
        if self.flag_friend in title_text:
            logger.debug(f"当前界面是-好友：{title_text}")
            return 2
        members_num = is_rooms(title_text)
        if members_num:
            logger.debug(f"当前界面是-微信群：{title_text},成员数量：{members_num}")
            return 3
        if title_text == "群聊":
            logger.debug("当前界面是:没有信息和内容 的 微信群，也可能是有问题的微信群，，")
            return 4
        # 没有判断出到到底是什么
        logger.debug(f"没有判断出来是什么功能，可能是公众号，：{title_text}")
        return 0

    def auto_rooms_saveto_book(self):
        """
        信息流界面的微信群，折叠，并保存到通讯录，

        :return:
        """
        room_name = self.wechat.chat_interface_title.get_text()
        # 进入聊天信息界面，
        self.wechat.chat_interface_info.click_gone()
        self.wechat.share_title.wait(timeout=self.back_wait_time)
        # title_text = poco("com.tencent.mm:id/ko4").get_text()
        # # 判断 标题中 是否包含 （）
        title_text = self.wechat.share_title.get_text()
        members_num = is_rooms(title_text)
        if not members_num:
            logger.debug(f"不是微信群-->{room_name}")
            self.wechat.key_back()
            # 等待 更多信息 出现，
            self.wechat.chat_interface_info.wait(timeout=5.0)
            self.wechat.key_back()
            self.wechat.share_title.wait(timeout=5.0)
            return
        logger.debug(f"群聊折叠进度：{room_name}")
        self.room_fold()
        # 点击保存到通讯录，
        self.room_switch_save_tobook()
        self.wechat.keyback_wait_for_appearance(self.wechat.chat_interface_title)
        self.wechat.key_back()

    def auto_view_information_flow(self, timeout):
        """
        自动查看信息流界面，点红点，
        :return:
        """
        logger.info(">>>>>>>进入 auto_view_information_flow ")
        # 点击 微信 进入信息流界面
        self.wechat.navbar_weixin.click()
        self.wechat.to_top()
        deadline = time.time() + timeout
        while time.time() < deadline:
            # 判断当前 有没有红点提示，如果没有就双击导航栏 微信，
            # 腾讯新闻，好友信息，企业通知 ，微信群
            self.wechat.double_click(self.wechat.navbar_weixin)
            flag_bth_redtip = False
            flag_bth_redtip2 = False
            if self.wechat.bth_redtip.wait(timeout=1):
                # 判断红点,是否在可点击的范围
                click_wait_for_appearance2(self.wechat.bth_redtip, self.wechat.chat_interface_back1,
                                           self.wechat.chat_interface_back2)
            else:
                flag_bth_redtip = True
            if flag_bth_redtip:
                if self.wechat.bth_redtip2.wait(timeout=1):
                    # 判断红点,是否在可点击的范围
                    logger.debug("小红点 存在")
                    click_wait_for_appearance2(self.wechat.bth_redtip2, self.wechat.chat_interface_back1,
                                               self.wechat.chat_interface_back2)
                else:
                    flag_bth_redtip2 = True
            if flag_bth_redtip and flag_bth_redtip2:
                # 当前页面没有红点提示，就双击 导航栏上的微信，
                logger.debug("当前页面，没有红点提示")
                continue
            # 进入了聊天界面，判断
            result = self.determine_interface()
            if result == 1:
                # 是微信的功能，
                self.wechat.keyback_wait_for_appearance(self.wechat.share_title)
            if result == 2:
                # 微信好友，
                # TODO: 目前直接退出，后续再加功能，
                self.wechat.keyback_wait_for_appearance(self.wechat.share_title)
            if result == 3:
                # 微信群，
                # 判断 是否已被退出，
                # 折叠，保存到通讯录，
                self.auto_rooms_saveto_book()
            if result == 4:
                # 群聊，判断是否已经被退出，或者解散，或者停用，
                if not self.room_is_exited():
                    self.wechat.keyback_wait_for_appearance(self.wechat.share_title)
            if result == 0:
                # 没有判断 出来，
                self.wechat.keyback_wait_for_appearance(self.wechat.share_title)
            if result == 9:
                logger.debug("当前页面是前面，不需要返回")

    def auto_rooms_to_hide(self, timeout):
        """
        把微信群，折叠，
        把这个方法拓展后，拆分，
        方法一，判断当前页面是否有红点，（两种红点），如果有，就点进去，如果没有就双击导航栏的微信，
        方法二，判断，进入的的row,是微信群，是好友，微信功能，公众号，企业通知，对于后三个直接返回，
        方法三，对于微信群，判断是否已经退出或者被退出 ，或者解散，或者停用，如果是正常状态，则点折叠和保存到通讯此，
        方法四，对于好友的，遍历，信息，找到最新的信息开始往下，记录到数据库（方便下次找到新起点），转发到主号，
        方法五，对于好友中，换群的，自动回拉，

        :return:
        """
        logger.debug(">>>>>>>进入 auto_rooms_to_hide ")
        # 点击 微信 进入信息流界面
        self.wechat.navbar_weixin.click()
        self.wechat.to_top()
        deadline = time.time() + timeout
        while time.time() < deadline:
            # 判断当前 有没有红点提示，如果没有就双击导航栏 微信，
            # 腾讯新闻，好友信息，企业通知 ，微信群
            if not self.wechat.bth_redtip.wait(timeout=1):
                # 当前页面没有红点提示，就双击 导航栏上的微信，
                self.wechat.double_click(self.wechat.navbar_weixin)
                continue
            # 判断红点,是否在可点击的范围
            if not self.wechat.is_clickable(self.wechat.bth_redtip):
                self.wechat.double_click(self.wechat.navbar_weixin)
                continue
            # 判断 红点,所在的bth,聊天hg4,名字,是否是群聊天
            row_name = self.wechat.bth_redtip_name.get_text()
            row_name = row_name.strip()
            logger.debug(f"遍历进度:{row_name}")
            if is_in_list(row_name, self.other_list):
                # 跳过微信的功能,
                logger.debug("跳过微信的功能,点击进入一下,取消红点,")
                self.wechat.bth_redtip.click_gone()
                self.wechat.keyback_wait_for_appearance(self.wechat.share_title)
                continue
            # if self.flag_friend in row_name:
            #     logger.debug("是好友的红点,先进入一玷,,取消红点,")
            #     self.wechat.table_rows_redtip.click_gone()
            #     self.wechat.keyback_wait_for_appearance(self.wechat.share_title)
            #     continue

            # 有红点，就点击,进入聊天界面
            click_wait_for_appearance(self.wechat.bth_redtip, self.wechat.chat_interface_title)
            # ，进入后判断是不是微信群，如果不是微信群，就退出 ，
            room_name = self.wechat.chat_interface_title.get_text()
            # 微信群的特征：进入聊天界面，标题 是以类似（433）结尾，
            members_num = is_rooms(room_name)
            if not members_num:
                # 不是微信群，直接返回，
                self.wechat.keyback_wait_for_appearance(self.wechat.share_title)
                continue
            # 第一次判断，应该是微信群，
            # 判断当前群，是不是已经被退出，
            if self.room_is_exited():
                continue
            # 进入聊天信息界面，
            self.wechat.chat_interface_info.click_gone()
            self.wechat.share_title.wait(timeout=self.back_wait_time)
            # title_text = poco("com.tencent.mm:id/ko4").get_text()
            # # 判断 标题中 是否包含 （）
            title_text = self.wechat.share_title.get_text()
            members_num = is_rooms(title_text)
            if not members_num:
                logger.debug(f"不是微信群-->{room_name}")
                self.wechat.key_back()
                # 等待 更多信息 出现，
                self.wechat.chat_interface_info.wait(timeout=5.0)
                self.wechat.key_back()
                self.wechat.share_title.wait(timeout=5.0)
                # 返回到 信息流界面，并继续，
                continue
            logger.debug(f"群聊折叠进度：{room_name}")
            # 点击保存到通讯录，
            self.room_switch_save_tobook()
            self.room_fold()

            self.wechat.keyback_wait_for_appearance(self.wechat.chat_interface_title)
            self.wechat.key_back()

    def auto_accept_friend_invitations(self):
        """
        自动接受好友邀请，并发送第一条信息，
        :return:
        """
        logger.info("auto_accept_friend_invitations")
        # 判断这个功能是否要执行，
        # 进入 通讯录，
        self.wechat.navbar_book.click()
        # 第二次点击，复位到通讯录顶部
        self.wechat.navbar_book.click()
        if self.internal_flag_auto_accept_friend_invitations:
            if self.wechat.book_label_newfriend.wait(timeout=2):
                logger.debug("没有好友邀请提示")
                return
            logger.debug("点击 好友邀请提示")
            click_wait_for_appearance(self.wechat.book_friend_invitations, self.wechat.new_friends_add)
        else:
            # 点击 新的朋友，
            logger.debug("点击 新的朋友，")
            click_wait_for_appearance(self.wechat.book_new_friend, self.wechat.new_friends_add)
        if not self.wechat.new_friend_accept.wait(timeout=2):
            logger.debug("没有接受按钮，")
            self.internal_flag_auto_accept_friend_invitations = 1
            self.wechat.keyback_homepage()
            return
        click_wait_for_appearance(self.wechat.new_friend_accept, self.wechat.new_friend_through)
        click_wait_for_appearance(self.wechat.new_friend_accept_done, self.wechat.friend_send_message)
        self.wechat.friend_send_message.click()
        self.wechat.chat_interface_edittext.set_text(settings.new_friend_message)
        self.wechat.chat_interface_send.click(timeout=3)
        # 回到信息流界面，
        self.wechat.keyback_homepage()
        self.internal_flag_auto_accept_friend_invitations = 0


if __name__ == '__main__':
     class WeixinTest:

        def __init__(self, serialno_url):
            # 判断 微信的版本号，8.0.40以后，app的层发生了变化 ，
            ver = packaging.version.parse("8.0.41")
            d = adb.device(serialno_url)
            info = d.app_info("com.tencent.mm")
            logger.info(f"微信版本号：{info.version_name}, version_code:{info.version_code}")
            if packaging.version.parse(info.version_name) < ver:
                self.wechat = wechat(serialno_url)
                logger.info("选择微信运行 第1版")
            else:
                logger.info("选择微信运行 第2版")
                self.wechat = wechat_2(serialno_url)

            self.serialno = self.wechat.serial

        def room_fold(self):
            """
            微信群的 聊天信息界面，点击 折叠到群聊
            :return:
            """
            # 点击 <消息免打扰>,最多点击 10次，少用while True
            for i in range(5):
                if self.wechat.room_switchs.exists():
                    break
                self.wechat.swipe_up(0.6, 0.4)
            for i in range(10):
                self.wechat.room_switchs[0].click()
                time.sleep(0.4)
                if self.wechat.is_closed(self.wechat.room_switchs[0]):
                    logger.debug("还是关闭状态，再点击一下")
                else:
                    break
            else:
                raise Exception("点击10次了，还是关闭状态，需要检查，")
            # 点击 <折叠该群聊>
            for i in range(10):
                self.wechat.room_switchs[1].click()
                # 点击 折叠群聊 后，可能出现弹窗，
                self.wechat.room_popup_tohide.click_exists(timeout=1)
                time.sleep(0.4)
                if self.wechat.is_closed(self.wechat.room_switchs[1]):
                    logger.debug("还是关闭状态，再点击一下")
                else:
                    break
            else:
                raise Exception("点击10次了，还是关闭状态，需要检查，")

        serial = "A3QU9X3608W04445"
        wd = WeixinTest(serial)
